From ef00fad6589a4af524b14d59002c19ebd97ff3bc Mon Sep 17 00:00:00 2001 From: miquelcampos Date: Tue, 22 Mar 2022 14:26:03 +0900 Subject: [PATCH] code format to black #102 --- .../EPIC_arm_01/__init__.py | 938 +++++++++-------- .../EPIC_chain_01/__init__.py | 52 +- .../EPIC_chain_01/guide.py | 50 +- .../EPIC_foot_01/__init__.py | 293 +++--- .../EPIC_foot_01/guide.py | 44 +- .../EPIC_leg_01/__init__.py | 623 ++++++----- .../EPIC_leg_01/guide.py | 169 ++- .../EPIC_mannequin_arm_01/__init__.py | 970 ++++++++++-------- .../EPIC_mannequin_arm_01/guide.py | 217 ++-- .../EPIC_mannequin_leg_01/__init__.py | 643 +++++++----- .../EPIC_mannequin_leg_01/guide.py | 169 ++- .../EPIC_neck_01/__init__.py | 482 +++++---- .../EPIC_neck_01/guide.py | 183 ++-- .../EPIC_shoulder_01/__init__.py | 70 +- .../EPIC_shoulder_01/guide.py | 27 +- .../EPIC_spine_cartoon_01/__init__.py | 406 +++++--- .../EPIC_spine_cartoon_01/guide.py | 163 +-- 17 files changed, 3188 insertions(+), 2311 deletions(-) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_arm_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_arm_01/__init__.py index d6745237..38810fda 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_arm_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_arm_01/__init__.py @@ -1,4 +1,3 @@ - import ast import pymel.core as pm from pymel.core import datatypes @@ -31,28 +30,37 @@ def addObjects(self): 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]) + 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) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[0], + self.guide.apos[1], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: x = datatypes.Vector(1, 0, 0) @@ -71,92 +79,106 @@ def addObjects(self): else: t_npo = t - self.fk0_npo = primitive.addTransform(self.root, - self.getName("fk0_npo"), - t_npo) - 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) + self.fk0_npo = primitive.addTransform( + self.root, self.getName("fk0_npo"), t_npo + ) + vec_po = datatypes.Vector(0.5 * self.length0 * self.n_factor, 0, 0) + self.fk0_ctl = self.addCtl( + self.fk0_npo, + "fk0_ctl", + t, + self.color_fk, + "cube", + w=self.length0, + h=self.size * 0.1, + d=self.size * 0.1, + po=vec_po, + tp=self.parentCtlTag, + ) attribute.setKeyableAttributes( - self.fk0_ctl, - ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[1], + self.guide.apos[2], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk0_ctl), self.guide.apos[1]) + transform.getTransform(self.fk0_ctl), self.guide.apos[1] + ) else: t_npo = t - self.fk1_npo = primitive.addTransform(self.fk0_ctl, - self.getName("fk1_npo"), - t_npo) - - vec_po = datatypes.Vector(.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) + self.fk1_npo = primitive.addTransform( + self.fk0_ctl, self.getName("fk1_npo"), t_npo + ) + + vec_po = datatypes.Vector(0.5 * self.length1 * self.n_factor, 0, 0) + self.fk1_ctl = self.addCtl( + self.fk1_npo, + "fk1_ctl", + t, + self.color_fk, + "cube", + w=self.length1, + h=self.size * 0.1, + d=self.size * 0.1, + po=vec_po, + tp=self.fk0_ctl, + ) attribute.setKeyableAttributes( - self.fk1_ctl, - ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"] + ) if self.settings["use_blade"]: - t = transform.getTransformLookingAt(self.guide.apos[2], - self.guide.apos[3], - self.blade_normal, - "x-z", - self.negate) + t = transform.getTransformLookingAt( + self.guide.apos[2], + self.guide.apos[3], + self.blade_normal, + "x-z", + self.negate, + ) else: - t = transform.getTransformLookingAt(self.guide.apos[2], - self.guide.apos[3], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.apos[2], + self.guide.apos[3], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk1_ctl), self.guide.apos[2]) + transform.getTransform(self.fk1_ctl), self.guide.apos[2] + ) else: t_npo = t - self.fk2_npo = primitive.addTransform(self.fk1_ctl, - self.getName("fk2_npo"), - t_npo) - - vec_po = datatypes.Vector(.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) + self.fk2_npo = primitive.addTransform( + self.fk1_ctl, self.getName("fk2_npo"), t_npo + ) + + vec_po = datatypes.Vector(0.5 * self.length2 * self.n_factor, 0, 0) + self.fk2_ctl = self.addCtl( + self.fk2_npo, + "fk2_ctl", + t, + self.color_fk, + "cube", + w=self.length2, + h=self.size * 0.1, + d=self.size * 0.1, + po=vec_po, + tp=self.fk1_ctl, + ) attribute.setKeyableAttributes(self.fk2_ctl) @@ -171,44 +193,49 @@ def addObjects(self): self.tip_ref = primitive.addTransform( self.armChainUpvRef[0], self.getName("tip_ref"), - self.armChainUpvRef[0].getMatrix(worldSpace=True)) + 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)) + 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)) + 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) + self.roll_ctl = self.addCtl( + self.roll_ctl_npo, + "roll_ctl", + transform.getTransform(self.roll_ctl_npo), + self.color_ik, + "compas", + w=self.size * 0.3, + ro=datatypes.Vector([off_x, off_y, 0]), + tp=self.parentCtlTag, + ) attribute.setKeyableAttributes(self.roll_ctl, ["rx"]) # create upv control v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() - v *= self.size * .8 + v *= self.size * 0.8 v += self.guide.apos[1] - self.upv_cns = primitive.addTransformFromPos(self.root, - self.getName("upv_cns"), - v) + self.upv_cns = primitive.addTransformFromPos( + self.root, self.getName("upv_cns"), v + ) self.upv_ctl = self.addCtl( self.upv_cns, @@ -216,8 +243,9 @@ def addObjects(self): transform.getTransform(self.upv_cns), self.color_ik, "diamond", - w=self.size * .12, - tp=self.parentCtlTag) + w=self.size * 0.12, + tp=self.parentCtlTag, + ) if self.settings["mirrorMid"]: if self.negate: @@ -230,16 +258,19 @@ def addObjects(self): # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos( - self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) + self.root, self.getName("ik_cns"), self.guide.pos["wrist"] + ) t = transform.getTransformFromPos(self.guide.pos["wrist"]) - self.ikcns_ctl = self.addCtl(self.ik_cns, - "ikcns_ctl", - t, - self.color_ik, - "null", - w=self.size * .12, - tp=self.parentCtlTag) + self.ikcns_ctl = self.addCtl( + self.ik_cns, + "ikcns_ctl", + t, + self.color_ik, + "null", + w=self.size * 0.12, + tp=self.parentCtlTag, + ) attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) @@ -254,28 +285,34 @@ def addObjects(self): if self.negate: - m = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - normal, - axis_ref1, - True) + m = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + normal, + axis_ref1, + True, + ) else: - m = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - normal, - axis_ref2, - False) - - self.ik_ctl = self.addCtl(self.ikcns_ctl, - "ik_ctl", - m, - self.color_ik, - "cube", - w=self.size * .12, - h=self.size * .12, - d=self.size * .12, - tp=self.roll_ctl) + m = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + normal, + axis_ref2, + False, + ) + + self.ik_ctl = self.addCtl( + self.ikcns_ctl, + "ik_ctl", + m, + self.color_ik, + "cube", + w=self.size * 0.12, + h=self.size * 0.12, + d=self.size * 0.12, + tp=self.roll_ctl, + ) if self.settings["mirrorIK"]: if self.negate: @@ -285,25 +322,27 @@ def addObjects(self): 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) + 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) + self.ikRot_npo = primitive.addTransform( + self.root, self.getName("ikRot_npo"), m + ) + self.ikRot_cns = primitive.addTransform( + self.ikRot_npo, self.getName("ikRot_cns"), m + ) + self.ikRot_ctl = self.addCtl( + self.ikRot_cns, + "ikRot_ctl", + m, + self.color_ik, + "sphere", + w=self.size * 0.12, + tp=self.ik_ctl, + ) attribute.setKeyableAttributes(self.ikRot_ctl, self.r_params) @@ -316,46 +355,50 @@ def addObjects(self): else: normal = self.normal axis_ref = "xz" - trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - normal, - axis_ref, - self.negate) - self.ik_ref = primitive.addTransform(self.ik_ctl_ref, - self.getName("ik_ref"), - trnIK_ref) - self.fk_ref = primitive.addTransform(self.fk_ctl[2], - self.getName("fk_ref"), - trnIK_ref) + trnIK_ref = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + normal, + axis_ref, + self.negate, + ) + self.ik_ref = primitive.addTransform( + self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref + ) + self.fk_ref = primitive.addTransform( + self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref + ) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root, self.getName("0_bone"), - transform.getTransform(self.fk_ctl[0])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone0_shp.setAttr("localScale", 0.5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root, self.getName("1_bone"), - transform.getTransform(self.fk_ctl[1])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone1_shp.setAttr("localScale", 0.5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) - self.ctrn_loc = primitive.addTransformFromPos(self.root, - self.getName("ctrn_loc"), - self.guide.apos[1]) - self.eff_loc = primitive.addTransformFromPos(self.root, - self.getName("eff_loc"), - self.guide.apos[2]) + self.ctrn_loc = primitive.addTransformFromPos( + self.root, self.getName("ctrn_loc"), self.guide.apos[1] + ) + self.eff_loc = primitive.addTransformFromPos( + self.root, self.getName("eff_loc"), self.guide.apos[2] + ) if self.settings["use_blade"]: # set the offset rotation for the hand @@ -364,51 +407,56 @@ def addObjects(self): self.guide.pos["eff"], self.blade_normal, axis="xy", - negate=self.negate) + negate=self.negate, + ) self.eff_jnt_off = primitive.addTransform( - self.eff_loc, - self.getName("eff_off"), - self.off_t) + self.eff_loc, self.getName("eff_off"), self.off_t + ) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) - self.mid_cns = primitive.addTransform(self.ctrn_loc, - self.getName("mid_cns"), - t) + self.mid_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) + self.mid_ctl = self.addCtl( + self.mid_cns, + "mid_ctl", + t, + self.color_ik, + "sphere", + w=self.size * 0.2, + tp=self.parentCtlTag, + ) - attribute.setKeyableAttributes(self.mid_ctl, - params=["tx", "ty", "tz", - "ro", "rx", "ry", "rz", - "sx"]) + 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, self.getName("mid_twst_npo"), t + ) self.mid_ctl_twst_ref = primitive.addTransform( - self.mid_ctl_twst_npo, - self.getName("mid_twst_ref"), - t) + 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) + 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) @@ -420,37 +468,45 @@ def addObjects(self): self.tws0_loc = primitive.addTransform( twst0_parent, self.getName("tws0_loc"), - transform.getTransform(self.fk_ctl[0])) + transform.getTransform(self.fk_ctl[0]), + ) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), - transform.getTransform(self.fk_ctl[0])) + transform.getTransform(self.fk_ctl[0]), + ) self.tws1_npo = primitive.addTransform( self.ctrn_loc, self.getName("tws1_npo"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws1_loc = primitive.addTransform( self.tws1_npo, self.getName("tws1_loc"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws2_npo = primitive.addTransform( self.root, self.getName("tws2_npo"), - transform.getTransform(self.fk_ctl[2])) + transform.getTransform(self.fk_ctl[2]), + ) self.tws2_loc = primitive.addTransform( self.tws2_npo, self.getName("tws2_loc"), - transform.getTransform(self.fk_ctl[2])) + transform.getTransform(self.fk_ctl[2]), + ) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), - transform.getTransform(self.fk_ctl[2])) + transform.getTransform(self.fk_ctl[2]), + ) # Divisions ---------------------------------------- @@ -464,22 +520,25 @@ def addObjects(self): for i in range(self.divisions): - div_cns = primitive.addTransform(self.root, - self.getName("div%s_loc" % i)) + 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) + tweak_ctl = self.addCtl( + div_cns, + "tweak%s_ctl" % i, + t, + self.color_fk, + "square", + w=self.size * 0.15, + d=self.size * 0.15, + ro=datatypes.Vector([0, 0, 1.5708]), + tp=tagP, + ) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl @@ -490,7 +549,8 @@ def addObjects(self): # joint Description Name jd_names = ast.literal_eval( - self.settings["jointNamesDescription_custom"]) + self.settings["jointNamesDescription_custom"] + ) upperarm = jd_names[0] lowerarm = jd_names[1] upperarm_twist_ = jd_names[2] @@ -512,9 +572,12 @@ def addObjects(self): increment = -1 else: self.jnt_pos.append( - [driver, - string.replaceSharpWithPadding(twist_name, twist_idx), - current_parent]) + [ + driver, + string.replaceSharpWithPadding(twist_name, twist_idx), + current_parent, + ] + ) twist_idx += increment if self.settings["use_blade"]: @@ -524,48 +587,45 @@ def addObjects(self): self.jnt_pos.append([eff_loc, hand, current_parent]) # match IK FK references - self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], - self.root, - "matchFk0_npo", - False) + self.match_fk0_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_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_off = self.add_match_ref( + self.fk_ctl[2], self.root, "matchFk1_npo", False + ) - self.match_fk1 = self.add_match_ref(self.fk_ctl[1], - self.match_fk1_off, - "fk1_mth") + self.match_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") + 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_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_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") + 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]) + self.getName("visalRef"), [self.upv_ctl, self.mid_ctl] + ) # ===================================================== # ATTRIBUTES @@ -574,113 +634,89 @@ def addAttributes(self): """Create the anim and setupr rig attributes for the component""" # Anim ------------------------------------------- - self.blend_att = self.addAnimParam("blend", - "Fk/Ik Blend", - "double", - self.settings["blend"], - 0, - 1) - self.roll_att = self.addAnimParam("roll", - "Roll", - "double", - 0, - -180, - 180) - self.armpit_roll_att = self.addAnimParam("aproll", - "Armpit Roll", - "double", - 0, - -360, - 360) - - self.scale_att = self.addAnimParam("ikscale", - "Scale", - "double", - 1, - .001, - 99) - self.maxstretch_att = self.addAnimParam("maxstretch", - "Max Stretch", - "double", - self.settings["maxstretch"], - 1, - 99) - self.slide_att = self.addAnimParam("slide", - "Slide", - "double", - .5, - 0, - 1) - self.softness_att = self.addAnimParam("softness", - "Softness", - "double", - 0, - 0, - 1) - self.reverse_att = self.addAnimParam("reverse", - "Reverse", - "double", - 0, - 0, - 1) - self.roundness_att = self.addAnimParam("roundness", - "Roundness", - "double", - 0, - 0, - self.size) - self.volume_att = self.addAnimParam("volume", - "Volume", - "double", - 1, - 0, - 1) + self.blend_att = self.addAnimParam( + "blend", "Fk/Ik Blend", "double", self.settings["blend"], 0, 1 + ) + self.roll_att = self.addAnimParam( + "roll", "Roll", "double", 0, -180, 180 + ) + self.armpit_roll_att = self.addAnimParam( + "aproll", "Armpit Roll", "double", 0, -360, 360 + ) + + self.scale_att = self.addAnimParam( + "ikscale", "Scale", "double", 1, 0.001, 99 + ) + self.maxstretch_att = self.addAnimParam( + "maxstretch", + "Max Stretch", + "double", + self.settings["maxstretch"], + 1, + 99, + ) + self.slide_att = self.addAnimParam( + "slide", "Slide", "double", 0.5, 0, 1 + ) + self.softness_att = self.addAnimParam( + "softness", "Softness", "double", 0, 0, 1 + ) + self.reverse_att = self.addAnimParam( + "reverse", "Reverse", "double", 0, 0, 1 + ) + self.roundness_att = self.addAnimParam( + "roundness", "Roundness", "double", 0, 0, self.size + ) + self.volume_att = self.addAnimParam( + "volume", "Volume", "double", 1, 0, 1 + ) if self.settings["extraTweak"]: self.tweakVis_att = self.addAnimParam( - "Tweak_vis", "Tweak Vis", "bool", False) + "Tweak_vis", "Tweak Vis", "bool", False + ) # Ref if self.settings["ikrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) if len(ref_names) > 1: self.ikref_att = self.addAnimEnumParam( - "ikref", - "Ik Ref", - 0, - ref_names) + "ikref", "Ik Ref", 0, ref_names + ) if self.settings["ikTR"]: ref_names = ["Auto", "ik_ctl"] if self.settings["ikrefarray"]: ref_names = ref_names + self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) - self.ikRotRef_att = self.addAnimEnumParam("ikRotRef", - "Ik Rot Ref", - 0, - ref_names) + self.ikRotRef_att = self.addAnimEnumParam( + "ikRotRef", "Ik Rot Ref", 0, ref_names + ) if self.settings["upvrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["upvrefarray"].split(",")) + self.settings["upvrefarray"].split(",") + ) ref_names = ["Auto"] + ref_names if len(ref_names) > 1: - self.upvref_att = self.addAnimEnumParam("upvref", - "UpV Ref", - 0, ref_names) + self.upvref_att = self.addAnimEnumParam( + "upvref", "UpV Ref", 0, ref_names + ) if self.settings["pinrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["pinrefarray"].split(",")) + self.settings["pinrefarray"].split(",") + ) ref_names = ["Auto"] + ref_names if len(ref_names) > 1: - self.pin_att = self.addAnimEnumParam("elbowref", - "Elbow Ref", - 0, - ref_names) + self.pin_att = self.addAnimEnumParam( + "elbowref", "Elbow Ref", 0, ref_names + ) if self.validProxyChannels: attrs_list = [self.blend_att, self.roundness_att] @@ -688,14 +724,18 @@ def addAttributes(self): attrs_list += [self.tweakVis_att] attribute.addProxyAttribute( attrs_list, - [self.fk0_ctl, + [ + self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.ik_ctl, self.upv_ctl, - self.mid_ctl]) - attribute.addProxyAttribute(self.roll_att, - [self.ik_ctl, self.upv_ctl]) + self.mid_ctl, + ], + ) + attribute.addProxyAttribute( + self.roll_att, [self.ik_ctl, self.upv_ctl] + ) # Setup ------------------------------------------ # Eval Fcurve @@ -703,34 +743,43 @@ def addAttributes(self): self.st_value = self.guide.paramDefs["st_profile"].value self.sq_value = self.guide.paramDefs["sq_profile"].value else: - self.st_value = fcurve.getFCurveValues(self.settings["st_profile"], - self.divisions) - self.sq_value = fcurve.getFCurveValues(self.settings["sq_profile"], - self.divisions) - - self.st_att = [self.addSetupParam("stretch_%s" % i, - "Stretch %s" % i, - "double", self.st_value[i], - -1, - 0) - for i in range(self.divisions)] - - self.sq_att = [self.addSetupParam("squash_%s" % i, - "Squash %s" % i, - "double", - self.sq_value[i], - 0, - 1) - for i in range(self.divisions)] - - self.resample_att = self.addSetupParam("resample", - "Resample", - "bool", - True) - self.absolute_att = self.addSetupParam("absolute", - "Absolute", - "bool", - False) + self.st_value = fcurve.getFCurveValues( + self.settings["st_profile"], self.divisions + ) + self.sq_value = fcurve.getFCurveValues( + self.settings["sq_profile"], self.divisions + ) + + self.st_att = [ + self.addSetupParam( + "stretch_%s" % i, + "Stretch %s" % i, + "double", + self.st_value[i], + -1, + 0, + ) + for i in range(self.divisions) + ] + + self.sq_att = [ + self.addSetupParam( + "squash_%s" % i, + "Squash %s" % i, + "double", + self.sq_value[i], + 0, + 1, + ) + for i in range(self.divisions) + ] + + self.resample_att = self.addSetupParam( + "resample", "Resample", "bool", True + ) + self.absolute_att = self.addSetupParam( + "absolute", "Absolute", "bool", False + ) # ===================================================== # OPERATORS @@ -748,12 +797,12 @@ def addOperators(self): self.root, self.getName("ikHandleArmChainUpvRef"), self.armChainUpvRef, - "ikSCsolver") - pm.pointConstraint(self.ik_ctl, - self.ikHandleUpvRef) - p_cns = pm.parentConstraint(self.armChainUpvRef[0], - self.upv_cns, - mo=True) + "ikSCsolver", + ) + pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef) + p_cns = pm.parentConstraint( + self.armChainUpvRef[0], self.upv_cns, mo=True + ) p_cns.interpType.set(0) # Visibilities ------------------------------------- @@ -792,16 +841,18 @@ def addOperators(self): # IK Solver ----------------------------------------- out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_loc] - o_node = applyop.gear_ikfk2bone_op(out, - self.root, - self.ik_ref, - self.upv_ctl, - self.fk_ctl[0], - self.fk_ctl[1], - self.fk_ref, - self.length0, - self.length1, - self.negate) + o_node = applyop.gear_ikfk2bone_op( + out, + self.root, + self.ik_ref, + self.upv_ctl, + self.fk_ctl[0], + self.fk_ctl[1], + self.fk_ref, + self.length0, + self.length1, + self.negate, + ) # NOTE: Ideally we should not change hierarchy or move object after # object generation method. But is much easier this way since every @@ -815,11 +866,13 @@ def addOperators(self): int_matrix = applyop.gear_intmatrix_op( self.armChainUpvRef[0].attr("worldMatrix"), self.tip_ref.attr("worldMatrix"), - .5) + 0.5, + ) applyop.gear_mulmatrix_op( int_matrix.attr("output"), self.interpolate_lvl.attr("parentInverseMatrix[0]"), - self.interpolate_lvl) + self.interpolate_lvl, + ) # match roll ctl npo to ctrn_loc current transform (so correct orient) transform.matchWorldTransform(self.ctrn_loc, self.roll_ctl_npo) @@ -845,10 +898,13 @@ def addOperators(self): # rotation mulM_node = applyop.gear_mulmatrix_op( self.ikRot_ctl.attr("worldMatrix"), - self.eff_loc.attr("parentInverseMatrix")) - intM_node = applyop.gear_intmatrix_op(o_node.attr("outEff"), - mulM_node.attr("output"), - o_node.attr("blend")) + self.eff_loc.attr("parentInverseMatrix"), + ) + intM_node = applyop.gear_intmatrix_op( + o_node.attr("outEff"), + mulM_node.attr("output"), + o_node.attr("blend"), + ) dm_node = node.createDecomposeMatrixNode(intM_node.attr("output")) dm_node.attr("outputRotate") >> self.eff_loc.attr("rotate") transform.matchWorldTransform(self.fk2_ctl, self.ikRot_cns) @@ -857,10 +913,11 @@ def addOperators(self): intM_node = applyop.gear_intmatrix_op( self.fk2_ctl.attr("worldMatrix"), self.ik_ctl_ref.attr("worldMatrix"), - o_node.attr("blend")) + o_node.attr("blend"), + ) mulM_node = applyop.gear_mulmatrix_op( - intM_node.attr("output"), - self.eff_loc.attr("parentInverseMatrix")) + intM_node.attr("output"), self.eff_loc.attr("parentInverseMatrix") + ) dm_node = node.createDecomposeMatrixNode(mulM_node.attr("output")) dm_node.attr("outputScale") >> self.eff_loc.attr("scale") @@ -871,14 +928,13 @@ def addOperators(self): else: mulVal = 1 rollMulVal = -1 - roll_m_node = node.createMulNode(self.roll_att, - mulVal) - roll_m_node2 = node.createMulNode(self.roll_ctl.attr("rx"), - rollMulVal) + roll_m_node = node.createMulNode(self.roll_att, mulVal) + roll_m_node2 = node.createMulNode(self.roll_ctl.attr("rx"), rollMulVal) node.createPlusMinusAverage1D( [roll_m_node.outputX, roll_m_node2.outputX], operation=1, - output=o_node + ".roll") + output=o_node + ".roll", + ) pm.connectAttr(self.scale_att, o_node + ".scaleA") pm.connectAttr(self.scale_att, o_node + ".scaleB") pm.connectAttr(self.maxstretch_att, o_node + ".maxstretch") @@ -888,18 +944,23 @@ def addOperators(self): # Twist references --------------------------------- - pm.pointConstraint(self.mid_ctl_twst_ref, - self.tws1_npo, maintainOffset=False) + pm.pointConstraint( + self.mid_ctl_twst_ref, self.tws1_npo, maintainOffset=False + ) pm.connectAttr(self.mid_ctl.scaleX, self.tws1_loc.scaleX) - pm.orientConstraint(self.mid_ctl_twst_ref, - self.tws1_npo, maintainOffset=False) + pm.orientConstraint( + self.mid_ctl_twst_ref, self.tws1_npo, maintainOffset=False + ) - o_node = applyop.gear_mulmatrix_op(self.eff_loc.attr( - "worldMatrix"), self.root.attr("worldInverseMatrix")) + o_node = applyop.gear_mulmatrix_op( + self.eff_loc.attr("worldMatrix"), + self.root.attr("worldInverseMatrix"), + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix") - pm.connectAttr(dm_node + ".outputTranslate", - self.tws2_npo.attr("translate")) + pm.connectAttr( + dm_node + ".outputTranslate", self.tws2_npo.attr("translate") + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix") @@ -907,23 +968,28 @@ def addOperators(self): o_node = applyop.gear_mulmatrix_op( self.eff_loc.attr("worldMatrix"), - self.tws2_rot.attr("parentInverseMatrix")) + self.tws2_rot.attr("parentInverseMatrix"), + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix") attribute.setRotOrder(self.tws2_rot, "XYZ") pm.connectAttr(dm_node + ".outputRotate", self.tws2_rot + ".rotate") - self.tws0_rot.setAttr("sx", .001) - self.tws2_rot.setAttr("sx", .001) + self.tws0_rot.setAttr("sx", 0.001) + self.tws2_rot.setAttr("sx", 0.001) - add_node = node.createAddNode(self.roundness_att, .0) + add_node = node.createAddNode(self.roundness_att, 0.0) pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx")) pm.connectAttr(self.armpit_roll_att, self.tws0_rot + ".rotateX") # Roll Shoulder - applyop.splineIK(self.getName("rollRef"), self.rollRef, - parent=self.root, cParent=self.bone0) + applyop.splineIK( + self.getName("rollRef"), + self.rollRef, + parent=self.root, + cParent=self.bone0, + ) if not self.settings["div0"]: applyop.oriCns(self.bone0, self.tws0_loc, maintainOffset=True) @@ -931,16 +997,19 @@ def addOperators(self): # Volume ------------------------------------------- distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc) distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc) - add_node = node.createAddNode(distA_node + ".distance", - distB_node + ".distance") - div_node = node.createDivNode(add_node + ".output", - self.root.attr("sx")) + add_node = node.createAddNode( + distA_node + ".distance", distB_node + ".distance" + ) + div_node = node.createDivNode( + add_node + ".output", self.root.attr("sx") + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(self.root.attr("worldMatrix"), dm_node + ".inputMatrix") - div_node2 = node.createDivNode(div_node + ".outputX", - dm_node + ".outputScaleX") + div_node2 = node.createDivNode( + div_node + ".outputX", dm_node + ".outputScaleX" + ) self.volDriver_att = div_node2 + ".outputX" if self.settings["extraTweak"]: @@ -954,32 +1023,39 @@ def addOperators(self): for i, div_cns in enumerate(self.div_cns): if i < (self.settings["div0"] + 1): - perc = i * .5 / (self.settings["div0"] + 1.0) + perc = i * 0.5 / (self.settings["div0"] + 1.0) elif i < (self.settings["div0"] + 2): - perc = .501 + perc = 0.501 else: - perc = .5 + \ - (i - self.settings["div0"] - 1.0) * .5 / \ - (self.settings["div1"] + 1.0) + perc = 0.5 + (i - self.settings["div0"] - 1.0) * 0.5 / ( + self.settings["div1"] + 1.0 + ) - perc = max(.0001, min(.999, perc)) + perc = max(0.0001, min(0.999, perc)) # Roll if self.negate: o_node = applyop.gear_rollsplinekine_op( - div_cns, [self.tws2_rot, self.tws1_rot, self.tws0_rot], - 1.0 - perc, 40) + div_cns, + [self.tws2_rot, self.tws1_rot, self.tws0_rot], + 1.0 - perc, + 40, + ) else: o_node = applyop.gear_rollsplinekine_op( - div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot], - perc, 40) + div_cns, + [self.tws0_rot, self.tws1_rot, self.tws2_rot], + perc, + 40, + ) pm.connectAttr(self.resample_att, o_node + ".resample") pm.connectAttr(self.absolute_att, o_node + ".absolute") # Squash n Stretch o_node = applyop.gear_squashstretch2_op( - div_cns, None, pm.getAttr(self.volDriver_att), "x") + div_cns, None, pm.getAttr(self.volDriver_att), "x" + ) pm.connectAttr(self.volume_att, o_node + ".blend") pm.connectAttr(self.volDriver_att, o_node + ".driver") pm.connectAttr(self.st_att[i], o_node + ".stretch") @@ -1040,35 +1116,37 @@ def connect_standard(self): self.connectRef(self.settings["upvrefarray"], self.upv_cns, True) init_refNames = ["lower_arm", "ik_ctl"] - self.connectRef2(self.settings["ikrefarray"], - self.ikRot_cns, - self.ikRotRef_att, - [self.ikRot_npo, self.ik_ctl], - True, - init_refNames) + self.connectRef2( + self.settings["ikrefarray"], + self.ikRot_cns, + self.ikRotRef_att, + [self.ikRot_npo, self.ik_ctl], + True, + init_refNames, + ) else: self.connect_standardWithIkRef() if self.settings["pinrefarray"]: - self.connectRef2(self.settings["pinrefarray"], - self.mid_cns, - self.pin_att, - [self.ctrn_loc], - False, - ["Auto"]) + self.connectRef2( + self.settings["pinrefarray"], + self.mid_cns, + self.pin_att, + [self.ctrn_loc], + False, + ["Auto"], + ) def connect_shoulder_01(self): - """ Custom connection to be use with shoulder 01 component""" + """Custom connection to be use with shoulder 01 component""" self.connect_standard() - pm.parent(self.rollRef[0], - self.ikHandleUpvRef, - self.parent_comp.ctl) + pm.parent(self.rollRef[0], self.ikHandleUpvRef, self.parent_comp.ctl) def collect_build_data(self): component.Main.collect_build_data(self) - self.build_data['DataContracts'] = ["Ik"] - self.build_data['Ik'] = [ + self.build_data["DataContracts"] = ["Ik"] + self.build_data["Ik"] = [ self.jointList[0].name(), self.jointList[self.settings["div0"] + 1].name(), - self.jointList[-1].name() + self.jointList[-1].name(), ] diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/__init__.py index 2d49a23a..874beb83 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/__init__.py @@ -30,13 +30,9 @@ def addObjects(self): self.n_factor = 1 if self.settings["overrideNegate"]: - self.mirror_conf = [0, 0, 1, - 1, 1, 0, - 0, 0, 0] + 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.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0] # FK controllers ------------------------------------ self.fk_npo = [] @@ -47,20 +43,24 @@ def addObjects(self): 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]) + 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)) + tOld, transform.getPositionFromMatrix(t) + ) fk_npo = primitive.addTransform( - parent, self.getName("fk%s_npo" % i), tnpo) + parent, self.getName("fk%s_npo" % i), tnpo + ) fk_ctl = self.addCtl( fk_npo, "fk%s_ctl" % i, @@ -68,11 +68,12 @@ def addObjects(self): self.color_fk, "cube", w=dist, - h=self.size * .1, - d=self.size * .1, - po=datatypes.Vector(dist * .5 * self.n_factor, 0, 0), + h=self.size * 0.1, + d=self.size * 0.1, + po=datatypes.Vector(dist * 0.5 * self.n_factor, 0, 0), tp=self.previusTag, - mirrorConf=self.mirror_conf) + mirrorConf=self.mirror_conf, + ) self.fk_npo.append(fk_npo) self.fk_ctl.append(fk_ctl) @@ -119,9 +120,12 @@ def setRelation(self): self.jointRelatives["%s_loc" % i] = i + 1 self.aliasRelatives["%s_ctl" % i] = i + 1 self.relatives["%s_loc" % (len(self.fk_ctl) - 1)] = self.fk_ctl[-1] - self.controlRelatives["%s_loc" % ( - len(self.fk_ctl) - 1)] = self.fk_ctl[-1] - self.jointRelatives["%s_loc" % ( - len(self.fk_ctl) - 1)] = len(self.fk_ctl) - 1 - self.aliasRelatives["%s_loc" % ( - len(self.fk_ctl) - 1)] = len(self.fk_ctl) - 1 + self.controlRelatives["%s_loc" % (len(self.fk_ctl) - 1)] = self.fk_ctl[ + -1 + ] + self.jointRelatives["%s_loc" % (len(self.fk_ctl) - 1)] = ( + len(self.fk_ctl) - 1 + ) + self.aliasRelatives["%s_loc" % (len(self.fk_ctl) - 1)] = ( + len(self.fk_ctl) - 1 + ) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/guide.py index 780b8364..8b8ac9ba 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_chain_01/guide.py @@ -17,8 +17,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_chain_01" NAME = "chain" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on lite_chain_01. Joint name taken from component instance name" +) ########################################################## # CLASS @@ -63,7 +65,9 @@ def addParameters(self): self.pAddJoints = self.addParam("addJoints", "bool", True) self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) + ########################################################## # Setting Page @@ -71,14 +75,12 @@ def addParameters(self): class settingsTab(QtWidgets.QDialog, sui.Ui_Form): - def __init__(self, parent=None): super(settingsTab, self).__init__(parent) self.setupUi(self) class componentSettings(MayaQWidgetDockableMixin, guide.componentMainSettings): - def __init__(self, parent=None): self.toolName = TYPE # Delete old instances of the componet settings window. @@ -115,12 +117,13 @@ def populate_componentControls(self): self.tabs.insertTab(1, self.settingsTab, "Component Settings") # populate component settings - self.populateCheck(self.settingsTab.neutralPose_checkBox, - "neutralpose") - self.populateCheck(self.settingsTab.overrideNegate_checkBox, - "overrideNegate") - self.populateCheck(self.settingsTab.addJoints_checkBox, - "addJoints") + self.populateCheck( + self.settingsTab.neutralPose_checkBox, "neutralpose" + ) + self.populateCheck( + self.settingsTab.overrideNegate_checkBox, "overrideNegate" + ) + self.populateCheck(self.settingsTab.addJoints_checkBox, "addJoints") def create_componentLayout(self): @@ -133,19 +136,28 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.neutralPose_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.neutralPose_checkBox, - "neutralpose")) + partial( + self.updateCheck, + self.settingsTab.neutralPose_checkBox, + "neutralpose", + ) + ) self.settingsTab.overrideNegate_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.overrideNegate_checkBox, - "overrideNegate")) + partial( + self.updateCheck, + self.settingsTab.overrideNegate_checkBox, + "overrideNegate", + ) + ) self.settingsTab.addJoints_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.addJoints_checkBox, - "addJoints")) + partial( + self.updateCheck, + self.settingsTab.addJoints_checkBox, + "addJoints", + ) + ) def dockCloseEventTriggered(self): pyqt.deleteInstances(self, MayaQDockWidget) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/__init__.py index 87fede82..96f2481d 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/__init__.py @@ -27,86 +27,107 @@ def addObjects(self): # Heel --------------------------------------------- # bank pivot - t = transform.getTransformLookingAt(self.guide.pos["heel"], - self.guide.apos[-4], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.pos["heel"], + self.guide.apos[-4], + self.normal, + "xz", + self.negate, + ) t = transform.setMatrixPosition(t, self.guide.pos["inpivot"]) self.in_npo = primitive.addTransform( - self.root, self.getName("in_npo"), t) + self.root, self.getName("in_npo"), t + ) self.in_piv = primitive.addTransform( - self.in_npo, self.getName("in_piv"), t) + self.in_npo, self.getName("in_piv"), t + ) t = transform.setMatrixPosition(t, self.guide.pos["outpivot"]) self.out_piv = primitive.addTransform( - self.in_piv, self.getName("out_piv"), t) + self.in_piv, self.getName("out_piv"), t + ) # heel - t = transform.getTransformLookingAt(self.guide.pos["heel"], - self.guide.apos[-4], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.pos["heel"], + self.guide.apos[-4], + self.normal, + "xz", + self.negate, + ) self.heel_loc = primitive.addTransform( - self.out_piv, self.getName("heel_loc"), t) + self.out_piv, self.getName("heel_loc"), t + ) attribute.setRotOrder(self.heel_loc, "YZX") - self.heel_ctl = self.addCtl(self.heel_loc, - "heel_ctl", - t, - self.color_ik, - "sphere", - w=self.size * .1, - tp=self.parentCtlTag) + self.heel_ctl = self.addCtl( + self.heel_loc, + "heel_ctl", + t, + self.color_ik, + "sphere", + w=self.size * 0.1, + tp=self.parentCtlTag, + ) attribute.setKeyableAttributes(self.heel_ctl, self.r_params) # Tip ---------------------------------------------- if self.up_axis == "y": - v = datatypes.Vector(self.guide.apos[-5].x, - self.guide.pos["heel"].y, - self.guide.apos[-5].z) + v = datatypes.Vector( + self.guide.apos[-5].x, + self.guide.pos["heel"].y, + self.guide.apos[-5].z, + ) else: - v = datatypes.Vector(self.guide.apos[-5].x, - self.guide.apos[-5].y, - self.guide.pos["heel"].z) + v = datatypes.Vector( + self.guide.apos[-5].x, + self.guide.apos[-5].y, + self.guide.pos["heel"].z, + ) t = transform.setMatrixPosition(t, v) - self.tip_ctl = self.addCtl(self.heel_ctl, - "tip_ctl", - t, - self.color_ik, - "circle", - w=self.size, - tp=self.heel_ctl) + self.tip_ctl = self.addCtl( + self.heel_ctl, + "tip_ctl", + t, + self.color_ik, + "circle", + w=self.size, + tp=self.heel_ctl, + ) attribute.setKeyableAttributes(self.tip_ctl, self.r_params) # Roll --------------------------------------------- if self.settings["useRollCtl"]: - t = transform.getTransformLookingAt(self.guide.pos["heel"], - self.guide.apos[-4], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.pos["heel"], + self.guide.apos[-4], + self.normal, + "xz", + self.negate, + ) t = transform.setMatrixPosition(t, self.guide.pos["root"]) self.roll_np = primitive.addTransform( - self.root, self.getName("roll_npo"), t) - - self.roll_ctl = self.addCtl(self.roll_np, - "roll_ctl", - t, - self.color_ik, - "cylinder", - w=self.size * .5, - h=self.size * .5, - ro=datatypes.Vector(3.1415 * .5, 0, 0), - tp=self.tip_ctl) + self.root, self.getName("roll_npo"), t + ) + + self.roll_ctl = self.addCtl( + self.roll_np, + "roll_ctl", + t, + self.color_ik, + "cylinder", + w=self.size * 0.5, + h=self.size * 0.5, + ro=datatypes.Vector(3.1415 * 0.5, 0, 0), + tp=self.tip_ctl, + ) attribute.setKeyableAttributes(self.roll_ctl, ["rx", "rz"]) @@ -125,17 +146,21 @@ def addObjects(self): else: direction = bk_pos[i - 1] t = transform.getTransformLookingAt( - pos, direction, self.normal, "xz", self.negate) + pos, direction, self.normal, "xz", self.negate + ) bk_loc = primitive.addTransform( - parent, self.getName("bk%s_loc" % i), t) - bk_ctl = self.addCtl(bk_loc, - "bk%s_ctl" % i, - t, - self.color_ik, - "sphere", - w=self.size * .15, - tp=self.previousTag) + parent, self.getName("bk%s_loc" % i), t + ) + bk_ctl = self.addCtl( + bk_loc, + "bk%s_ctl" % i, + t, + self.color_ik, + "sphere", + w=self.size * 0.15, + tp=self.previousTag, + ) attribute.setKeyableAttributes(bk_ctl, self.r_params) self.previousTag = bk_ctl @@ -144,13 +169,14 @@ def addObjects(self): parent = bk_ctl # FK Reference ------------------------------------ - self.fk_ref = primitive.addTransformFromPos(self.bk_ctl[-1], - self.getName("fk_ref"), - self.guide.apos[0]) + self.fk_ref = primitive.addTransformFromPos( + self.bk_ctl[-1], self.getName("fk_ref"), self.guide.apos[0] + ) self.fk_npo = primitive.addTransform( self.fk_ref, self.getName("fk0_npo"), - transform.getTransform(self.bk_ctl[-1])) + transform.getTransform(self.bk_ctl[-1]), + ) # Forward Controlers ------------------------------ self.fk_ctl = [] @@ -164,23 +190,27 @@ def addObjects(self): t = transform.setMatrixPosition(t, v) else: t = transform.getTransform(bk_ctl) - dist = vector.getDistance(self.guide.apos[i + 1], - self.guide.apos[i + 2]) + dist = vector.getDistance( + self.guide.apos[i + 1], self.guide.apos[i + 2] + ) fk_loc = primitive.addTransform( - parent, self.getName("fk%s_loc" % i), t) - - po_vec = datatypes.Vector(dist * .5 * self.n_factor, 0, 0) - fk_ctl = self.addCtl(fk_loc, - "fk%s_ctl" % i, - t, - self.color_fk, - "cube", - w=dist, - h=self.size * .5, - d=self.size * .5, - po=po_vec, - tp=self.previousTag) + parent, self.getName("fk%s_loc" % i), t + ) + + po_vec = datatypes.Vector(dist * 0.5 * self.n_factor, 0, 0) + fk_ctl = self.addCtl( + fk_loc, + "fk%s_ctl" % i, + t, + self.color_fk, + "cube", + w=dist, + h=self.size * 0.5, + d=self.size * 0.5, + po=po_vec, + tp=self.previousTag, + ) self.previousTag = fk_ctl attribute.setKeyableAttributes(fk_ctl) @@ -204,18 +234,21 @@ def addAttributes(self): # Roll Angles if not self.settings["useRollCtl"]: self.roll_att = self.addAnimParam( - "roll", "Roll", "double", 0, -180, 180) + "roll", "Roll", "double", 0, -180, 180 + ) self.bank_att = self.addAnimParam( - "bank", "Bank", "double", 0, -180, 180) + "bank", "Bank", "double", 0, -180, 180 + ) - self.angles_att = [self.addAnimParam("angle_%s" % i, - "Angle %s" % i, - "double", -20) - for i in range(self.div_count)] + self.angles_att = [ + self.addAnimParam("angle_%s" % i, "Angle %s" % i, "double", -20) + for i in range(self.div_count) + ] # Setup ------------------------------------------ self.blend_att = self.addSetupParam( - "blend", "Fk/Ik Blend", "double", 1, 0, 1) + "blend", "Fk/Ik Blend", "double", 1, 0, 1 + ) # ===================================================== # OPERATORS @@ -253,11 +286,13 @@ def addOperators(self): clamp_node = node.createClampNode( [self.roll_att, self.bank_att, self.bank_att], [0, -180, 0], - [180, 0, 180]) + [180, 0, 180], + ) inAdd_nod = node.createAddNode( clamp_node.outputB, - pm.getAttr(self.in_piv.attr("rx")) * self.n_factor) + pm.getAttr(self.in_piv.attr("rx")) * self.n_factor, + ) pm.connectAttr(clamp_node.outputR, self.heel_loc.attr("rz")) pm.connectAttr(clamp_node.outputG, self.out_piv.attr("rx")) @@ -272,21 +307,24 @@ def addOperators(self): min_input = self.angles_att[i] elif i == len(self.angles_att): # Last - sub_nod = node.createSubNode(self.roll_att, - angle_outputs[i - 1]) + sub_nod = node.createSubNode( + self.roll_att, angle_outputs[i - 1] + ) inpu = sub_nod.output min_input = -360 else: # Others - sub_nod = node.createSubNode(self.roll_att, - angle_outputs[i - 1]) + sub_nod = node.createSubNode( + self.roll_att, angle_outputs[i - 1] + ) inpu = sub_nod.output min_input = self.angles_att[i] clamp_node = node.createClampNode(inpu, min_input, 0) - add_node = node.createAddNode(clamp_node.outputR, - bk_loc.getAttr("rz")) + add_node = node.createAddNode( + clamp_node.outputR, bk_loc.getAttr("rz") + ) pm.connectAttr(add_node.output, bk_loc.attr("rz")) @@ -305,32 +343,34 @@ def addOperators(self): # Compensate the backward rotation # ik addx_node = node.createAddNode( - bk_ctl.attr("rx"), bk_loc.attr("rx")) + bk_ctl.attr("rx"), bk_loc.attr("rx") + ) addy_node = node.createAddNode( - bk_ctl.attr("ry"), bk_loc.attr("ry")) + bk_ctl.attr("ry"), bk_loc.attr("ry") + ) addz_node = node.createAddNode( - bk_ctl.attr("rz"), bk_loc.attr("rz")) + bk_ctl.attr("rz"), bk_loc.attr("rz") + ) addz_node = node.createAddNode( - addz_node.output, - -bk_loc.getAttr("rz") - fk_loc.getAttr("rz")) - - neg_node = node.createMulNode([addx_node.output, - addy_node.output, - addz_node.output], - [-1, -1, -1]) - add_node = node.createAddNode(neg_node.outputY.get() * -1, - neg_node.outputY) - ik_outputs = [neg_node.outputX, - add_node.output, - neg_node.outputZ] + addz_node.output, -bk_loc.getAttr("rz") - fk_loc.getAttr("rz") + ) + + neg_node = node.createMulNode( + [addx_node.output, addy_node.output, addz_node.output], + [-1, -1, -1], + ) + add_node = node.createAddNode( + neg_node.outputY.get() * -1, neg_node.outputY + ) + ik_outputs = [neg_node.outputX, add_node.output, neg_node.outputZ] # fk fk_outputs = [0, 0, fk_loc.getAttr("rz")] # blend - blend_node = node.createBlendNode(ik_outputs, - fk_outputs, - self.blend_att) + blend_node = node.createBlendNode( + ik_outputs, fk_outputs, self.blend_att + ) pm.connectAttr(blend_node.output, fk_loc.attr("rotate")) return @@ -383,7 +423,8 @@ def connect_leg_2jnt_01(self): pm.parent(self.root, self.parent_comp.ik_ctl) pm.parent(self.parent_comp.ik_ref, self.bk_ctl[-1]) pm.parentConstraint( - self.parent_comp.tws2_rot, self.fk_ref, maintainOffset=True) + self.parent_comp.tws2_rot, self.fk_ref, maintainOffset=True + ) return @@ -397,17 +438,22 @@ def connect_leg_ms_2jnt_01(self): pm.connectAttr(self.parent_comp.blend_att, self.blend_att) pm.parent(self.root, self.parent_comp.ik_ctl) pm.parent(self.parent_comp.ik_ref, self.bk_ctl[-1]) - pm.parentConstraint(self.parent_comp.tws3_rot, - self.fk_ref, - maintainOffset=True) - cns = pm.scaleConstraint(self.parent_comp.fk_ref, - self.parent_comp.ik_ref, - self.fk_ref, wal=True) + pm.parentConstraint( + self.parent_comp.tws3_rot, self.fk_ref, maintainOffset=True + ) + cns = pm.scaleConstraint( + self.parent_comp.fk_ref, + self.parent_comp.ik_ref, + self.fk_ref, + wal=True, + ) bc_node = pm.createNode("blendColors") - pm.connectAttr(bc_node.outputB, - cns + ".%sW0" % self.parent_comp.fk_ref) - pm.connectAttr(bc_node.outputR, - cns + ".%sW1" % self.parent_comp.ik_ref) + pm.connectAttr( + bc_node.outputB, cns + ".%sW0" % self.parent_comp.fk_ref + ) + pm.connectAttr( + bc_node.outputR, cns + ".%sW1" % self.parent_comp.ik_ref + ) pm.connectAttr(self.parent_comp.blend_att, bc_node.blender) return @@ -424,6 +470,7 @@ def connect_leg_3jnt_01(self): pm.parent(self.parent_comp.ik_ref, self.bk_ctl[-1]) pm.parent(self.parent_comp.ik2b_ikCtl_ref, self.bk_ctl[-1]) pm.parentConstraint( - self.parent_comp.tws3_rot, self.fk_ref, maintainOffset=True) + self.parent_comp.tws3_rot, self.fk_ref, maintainOffset=True + ) return diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/guide.py index 799dfda8..bf183315 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_foot_01/guide.py @@ -17,8 +17,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_foot_01" NAME = "foot" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on foot_bk_01" +) ########################################################## # CLASS @@ -37,10 +39,12 @@ class Guide(guide.ComponentGuide): email = EMAIL version = VERSION - connectors = ["EPIC_leg_01", - "leg_2jnt_01", - "leg_ms_2jnt_01", - "leg_3jnt_01"] + connectors = [ + "EPIC_leg_01", + "leg_2jnt_01", + "leg_ms_2jnt_01", + "leg_3jnt_01", + ] def postInit(self): """Initialize the position for the guide""" @@ -74,13 +78,15 @@ def addParameters(self): self.pRoll = self.addParam("useRollCtl", "bool", True) self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) ########################################################## # Setting Page ########################################################## + class settingsTab(QtWidgets.QDialog, sui.Ui_Form): """The Component settings UI""" @@ -139,9 +145,11 @@ def populate_componentControls(self): if currentConnector not in self.connector_items: self.mainSettingsTab.connector_comboBox.addItem(currentConnector) self.connector_items.append(currentConnector) - pm.displayWarning("The current connector: %s, is not a valid " - "connector for this component. " - "Build will Fail!!") + pm.displayWarning( + "The current connector: %s, is not a valid " + "connector for this component. " + "Build will Fail!!" + ) comboIndex = self.connector_items.index(currentConnector) self.mainSettingsTab.connector_comboBox.setCurrentIndex(comboIndex) @@ -156,13 +164,19 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.useRollCtl_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.useRollCtl_checkBox, - "useRollCtl")) + partial( + self.updateCheck, + self.settingsTab.useRollCtl_checkBox, + "useRollCtl", + ) + ) self.mainSettingsTab.connector_comboBox.currentIndexChanged.connect( - partial(self.updateConnector, - self.mainSettingsTab.connector_comboBox, - self.connector_items)) + partial( + self.updateConnector, + self.mainSettingsTab.connector_comboBox, + self.connector_items, + ) + ) def dockCloseEventTriggered(self): pyqt.deleteInstances(self, MayaQDockWidget) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/__init__.py index b018bcd8..44c009f6 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/__init__.py @@ -1,4 +1,3 @@ - import pymel.core as pm from pymel.core import datatypes @@ -27,11 +26,14 @@ def addObjects(self): self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance( - self.guide.apos[0], self.guide.apos[1]) + self.guide.apos[0], self.guide.apos[1] + ) self.length1 = vector.getDistance( - self.guide.apos[1], self.guide.apos[2]) + self.guide.apos[1], self.guide.apos[2] + ) self.length2 = vector.getDistance( - self.guide.apos[2], self.guide.apos[3]) + self.guide.apos[2], self.guide.apos[3] + ) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( @@ -40,32 +42,37 @@ def addObjects(self): [self.guide.apos[0], self.guide.apos[2]], self.normal, False, - self.WIP) + self.WIP, + ) self.legChainUpvRef[1].setAttr( - "jointOrientZ", - self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) + "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1 + ) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) - self.root_npo = primitive.addTransform(self.root, - self.getName("root_npo"), - t) - self.root_ctl = self.addCtl(self.root_npo, - "root_ctl", - t, - self.color_fk, - "circle", - w=self.length0 / 6, - tp=self.parentCtlTag) + self.root_npo = primitive.addTransform( + self.root, self.getName("root_npo"), t + ) + self.root_ctl = self.addCtl( + self.root_npo, + "root_ctl", + t, + self.color_fk, + "circle", + w=self.length0 / 6, + tp=self.parentCtlTag, + ) # FK Controlers ----------------------------------- - t = transform.getTransformLookingAt(self.guide.apos[0], - self.guide.apos[1], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.apos[0], + self.guide.apos[1], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: if self.negate: x_dir = 1 @@ -83,81 +90,97 @@ def addObjects(self): else: t_npo = t - self.fk0_npo = primitive.addTransform(self.root_ctl, - self.getName("fk0_npo"), - t_npo) - po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) - self.fk0_ctl = self.addCtl(self.fk0_npo, - "fk0_ctl", - t, - self.color_fk, - "cube", - w=self.length0, - h=self.size * .1, - d=self.size * .1, - po=po_vec, - tp=self.root_ctl) + self.fk0_npo = primitive.addTransform( + self.root_ctl, self.getName("fk0_npo"), t_npo + ) + po_vec = datatypes.Vector(0.5 * self.length0 * self.n_factor, 0, 0) + self.fk0_ctl = self.addCtl( + self.fk0_npo, + "fk0_ctl", + t, + self.color_fk, + "cube", + w=self.length0, + h=self.size * 0.1, + d=self.size * 0.1, + po=po_vec, + tp=self.root_ctl, + ) attribute.setKeyableAttributes( - self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[1], + self.guide.apos[2], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk0_ctl), self.guide.apos[1]) + transform.getTransform(self.fk0_ctl), self.guide.apos[1] + ) else: t_npo = t self.fk1_npo = primitive.addTransform( - self.fk0_ctl, self.getName("fk1_npo"), t_npo) - - po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) - self.fk1_ctl = self.addCtl(self.fk1_npo, - "fk1_ctl", - t, - self.color_fk, - "cube", - w=self.length1, - h=self.size * .1, - d=self.size * .1, - po=po_vec, - tp=self.fk0_ctl) + self.fk0_ctl, self.getName("fk1_npo"), t_npo + ) + + po_vec = datatypes.Vector(0.5 * self.length1 * self.n_factor, 0, 0) + self.fk1_ctl = self.addCtl( + self.fk1_npo, + "fk1_ctl", + t, + self.color_fk, + "cube", + w=self.length1, + h=self.size * 0.1, + d=self.size * 0.1, + po=po_vec, + tp=self.fk0_ctl, + ) attribute.setKeyableAttributes( - self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[2], + self.guide.apos[3], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk0_ctl), self.guide.apos[2]) + transform.getTransform(self.fk0_ctl), self.guide.apos[2] + ) else: t_npo = t self.fk2_npo = primitive.addTransform( - self.fk1_ctl, self.getName("fk2_npo"), t_npo) + self.fk1_ctl, self.getName("fk2_npo"), t_npo + ) if self.settings["FK_rest_T_Pose"]: self.fk2_npo.rz.set(90) - po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) - self.fk2_ctl = self.addCtl(self.fk2_npo, - "fk2_ctl", - t, - self.color_fk, - "cube", - w=self.length2, - h=self.size * .1, - d=self.size * .1, - po=po_vec, - tp=self.fk1_ctl) + po_vec = datatypes.Vector(0.5 * self.length2 * self.n_factor, 0, 0) + self.fk2_ctl = self.addCtl( + self.fk2_npo, + "fk2_ctl", + t, + self.color_fk, + "cube", + w=self.length2, + h=self.size * 0.1, + d=self.size * 0.1, + po=po_vec, + tp=self.fk1_ctl, + ) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] @@ -167,9 +190,9 @@ def addObjects(self): # IK Controlers ----------------------------------- - self.ik_cns = primitive.addTransformFromPos(self.root_ctl, - self.getName("ik_cns"), - self.guide.pos["ankle"]) + self.ik_cns = primitive.addTransformFromPos( + self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"] + ) self.ikcns_ctl = self.addCtl( self.ik_cns, @@ -177,8 +200,9 @@ def addObjects(self): transform.getTransformFromPos(self.guide.pos["ankle"]), self.color_ik, "null", - w=self.size * .12, - tp=self.root_ctl) + w=self.size * 0.12, + tp=self.root_ctl, + ) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) # m = transform.getTransformLookingAt(self.guide.pos["ankle"], @@ -201,9 +225,10 @@ def addObjects(self): t_ik, self.color_ik, "cube", - w=self.size * .12, - h=self.size * .12, - d=self.size * .12) + w=self.size * 0.12, + h=self.size * 0.12, + d=self.size * 0.12, + ) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) @@ -212,12 +237,12 @@ def addObjects(self): v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() - v *= self.size * .5 + v *= self.size * 0.5 v += self.guide.apos[1] - self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, - self.getName("upv_cns"), - v) + self.upv_cns = primitive.addTransformFromPos( + self.ik_ctl, self.getName("upv_cns"), v + ) self.upv_ctl = self.addCtl( self.upv_cns, @@ -225,8 +250,9 @@ def addObjects(self): transform.getTransform(self.upv_cns), self.color_ik, "diamond", - w=self.size * .12, - tp=self.root_ctl) + w=self.size * 0.12, + tp=self.root_ctl, + ) self.add_controller_tag(self.ik_ctl, self.upv_ctl) if self.settings["mirrorMid"]: @@ -241,70 +267,80 @@ def addObjects(self): self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), - transform.getTransform(self.ik_ctl)) + transform.getTransform(self.ik_ctl), + ) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), - transform.getTransform(self.ik_ctl)) + transform.getTransform(self.ik_ctl), + ) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), - transform.getTransform(self.fk_ctl[0])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone0_shp.setAttr("localScale", 0.5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), - transform.getTransform(self.fk_ctl[1])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone1_shp.setAttr("localScale", 0.5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) - self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl, - self.getName("ctrn_loc"), - self.guide.apos[1]) - self.eff_loc = primitive.addTransformFromPos(self.root_ctl, - self.getName("eff_loc"), - self.guide.apos[2]) + self.ctrn_loc = primitive.addTransformFromPos( + self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1] + ) + self.eff_loc = primitive.addTransformFromPos( + self.root_ctl, self.getName("eff_loc"), self.guide.apos[2] + ) # tws_ref t = transform.getRotationFromAxis( - datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) + datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate + ) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) # addind an npo parent transform to fix flip in Maya 2018.2 self.tws_npo = primitive.addTransform( - self.eff_loc, self.getName("tws_npo"), t) + self.eff_loc, self.getName("tws_npo"), t + ) self.tws_ref = primitive.addTransform( - self.tws_npo, self.getName("tws_ref"), t) + self.tws_npo, self.getName("tws_ref"), t + ) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform( - self.ctrn_loc, self.getName("mid_cns"), t) - self.mid_ctl = self.addCtl(self.mid_cns, - "mid_ctl", - t, - self.color_ik, - "sphere", - w=self.size * .2, - tp=self.root_ctl) - - attribute.setKeyableAttributes(self.mid_ctl, - params=["tx", "ty", "tz", - "ro", "rx", "ry", "rz", - "sx"]) + self.ctrn_loc, self.getName("mid_cns"), t + ) + self.mid_ctl = self.addCtl( + self.mid_cns, + "mid_ctl", + t, + self.color_ik, + "sphere", + w=self.size * 0.2, + tp=self.root_ctl, + ) + + attribute.setKeyableAttributes( + self.mid_ctl, + params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"], + ) if self.settings["mirrorMid"]: if self.negate: @@ -321,46 +357,55 @@ def addObjects(self): m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition( - m, transform.getTranslation(self.ik_ctl)) + m, transform.getTranslation(self.ik_ctl) + ) - self.rollRef = primitive.add2DChain(self.root, - self.getName("rollChain"), - self.guide.apos[:2], - self.normal, - self.negate, - self.WIP) + self.rollRef = primitive.add2DChain( + self.root, + self.getName("rollChain"), + self.guide.apos[:2], + self.normal, + self.negate, + self.WIP, + ) self.tws0_loc = primitive.addTransform( self.root_ctl, self.getName("tws0_loc"), - transform.getTransform(self.fk_ctl[0])) + transform.getTransform(self.fk_ctl[0]), + ) self.tws0_rot = primitive.addTransform( self.tws0_loc, self.getName("tws0_rot"), - transform.getTransform(self.fk_ctl[0])) + transform.getTransform(self.fk_ctl[0]), + ) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws2_loc = primitive.addTransform( self.root_ctl, self.getName("tws2_loc"), - transform.getTransform(self.tws_ref)) + transform.getTransform(self.tws_ref), + ) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), - transform.getTransform(self.tws_ref)) + transform.getTransform(self.tws_ref), + ) - self.tws2_rot.setAttr("sx", .001) + self.tws2_rot.setAttr("sx", 0.001) # Divisions ---------------------------------------- @@ -374,22 +419,25 @@ def addObjects(self): for i in range(self.divisions): - div_cns = primitive.addTransform(self.root_ctl, - self.getName("div%s_loc" % i)) + div_cns = primitive.addTransform( + self.root_ctl, self.getName("div%s_loc" % i) + ) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) - tweak_ctl = self.addCtl(div_cns, - "tweak%s_ctl" % i, - t, - self.color_fk, - "square", - w=self.size * .15, - d=self.size * .15, - ro=datatypes.Vector([0, 0, 1.5708]), - tp=tagP) + tweak_ctl = self.addCtl( + div_cns, + "tweak%s_ctl" % i, + t, + self.color_fk, + "square", + w=self.size * 0.15, + d=self.size * 0.15, + ro=datatypes.Vector([0, 0, 1.5708]), + tp=tagP, + ) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl @@ -413,128 +461,149 @@ def addObjects(self): increment = -1 else: self.jnt_pos.append( - [driver, - twist_name + str(twist_idx).zfill(2), - current_parent]) + [ + driver, + twist_name + str(twist_idx).zfill(2), + current_parent, + ] + ) twist_idx += increment # End reference ------------------------------------ # To help the deformation on the ankle - self.end_ref = primitive.addTransform(self.tws2_rot, - self.getName("end_ref"), m) + self.end_ref = primitive.addTransform( + self.tws2_rot, self.getName("end_ref"), m + ) # set the offset rotation for the hand - self.end_jnt_off = primitive.addTransform(self.end_ref, - self.getName("end_off"), m) + self.end_jnt_off = primitive.addTransform( + self.end_ref, self.getName("end_off"), m + ) if self.up_axis == "z": self.end_jnt_off.rz.set(-90) - self.jnt_pos.append([self.end_jnt_off, 'foot', current_parent]) + self.jnt_pos.append([self.end_jnt_off, "foot", current_parent]) # match IK FK references - self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], - self.root, - "matchFk0_npo", - False) + self.match_fk0_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_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_off = self.add_match_ref( + self.fk_ctl[2], self.root, "matchFk1_npo", False + ) - self.match_fk1 = self.add_match_ref(self.fk_ctl[1], - self.match_fk1_off, - "fk1_mth") + self.match_fk1 = self.add_match_ref( + self.fk_ctl[1], self.match_fk1_off, "fk1_mth" + ) - self.match_fk2 = self.add_match_ref(self.fk_ctl[2], - self.ik_ctl, - "fk2_mth") + self.match_fk2 = self.add_match_ref( + self.fk_ctl[2], self.ik_ctl, "fk2_mth" + ) - self.match_ik = self.add_match_ref(self.ik_ctl, - self.fk2_ctl, - "ik_mth") + self.match_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") + 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]) + self.getName("visalRef"), [self.upv_ctl, self.mid_ctl] + ) def addAttributes(self): # Anim ------------------------------------------- self.blend_att = self.addAnimParam( - "blend", "Fk/Ik Blend", "double", self.settings["blend"], 0, 1) + "blend", "Fk/Ik Blend", "double", self.settings["blend"], 0, 1 + ) self.roll_att = self.addAnimParam( - "roll", "Roll", "double", 0, -180, 180) + "roll", "Roll", "double", 0, -180, 180 + ) self.scale_att = self.addAnimParam( - "ikscale", "Scale", "double", 1, .001, 99) - self.maxstretch_att = self.addAnimParam("maxstretch", - "Max Stretch", - "double", - self.settings["maxstretch"], - 1, - 99) + "ikscale", "Scale", "double", 1, 0.001, 99 + ) + self.maxstretch_att = self.addAnimParam( + "maxstretch", + "Max Stretch", + "double", + self.settings["maxstretch"], + 1, + 99, + ) self.slide_att = self.addAnimParam( - "slide", "Slide", "double", .5, 0, 1) + "slide", "Slide", "double", 0.5, 0, 1 + ) self.softness_att = self.addAnimParam( - "softness", "Softness", "double", 0, 0, 1) + "softness", "Softness", "double", 0, 0, 1 + ) self.reverse_att = self.addAnimParam( - "reverse", "Reverse", "double", 0, 0, 1) + "reverse", "Reverse", "double", 0, 0, 1 + ) self.roundness_att = self.addAnimParam( - "roundness", "Roundness", "double", 0, 0, self.size) + "roundness", "Roundness", "double", 0, 0, self.size + ) self.volume_att = self.addAnimParam( - "volume", "Volume", "double", 1, 0, 1) + "volume", "Volume", "double", 1, 0, 1 + ) if self.settings["extraTweak"]: self.tweakVis_att = self.addAnimParam( - "Tweak_vis", "Tweak Vis", "bool", False) + "Tweak_vis", "Tweak Vis", "bool", False + ) # Ref if self.settings["ikrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) if len(ref_names) > 1: self.ikref_att = self.addAnimEnumParam( "ikref", "Ik Ref", 0, - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(","), + ) ref_names = ["Auto", "ikFoot"] if self.settings["upvrefarray"]: ref_names = ref_names + self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) self.upvref_att = self.addAnimEnumParam( - "upvref", "UpV Ref", 0, ref_names) + "upvref", "UpV Ref", 0, ref_names + ) if self.settings["pinrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["pinrefarray"].split(",")) + self.settings["pinrefarray"].split(",") + ) ref_names = ["Auto"] + ref_names if len(ref_names) > 1: - self.pin_att = self.addAnimEnumParam("kneeref", - "Knee Ref", - 0, - ref_names) + self.pin_att = self.addAnimEnumParam( + "kneeref", "Knee Ref", 0, ref_names + ) if self.validProxyChannels: attrs_list = [self.blend_att, self.roundness_att] if self.settings["extraTweak"]: attrs_list += [self.tweakVis_att] attribute.addProxyAttribute( attrs_list, - [self.fk0_ctl, + [ + self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.ik_ctl, self.upv_ctl, - self.mid_ctl]) - attribute.addProxyAttribute(self.roll_att, - [self.ik_ctl, self.upv_ctl]) + self.mid_ctl, + ], + ) + attribute.addProxyAttribute( + self.roll_att, [self.ik_ctl, self.upv_ctl] + ) # Setup ------------------------------------------ # Eval Fcurve @@ -542,25 +611,42 @@ def addAttributes(self): self.st_value = self.guide.paramDefs["st_profile"].value self.sq_value = self.guide.paramDefs["sq_profile"].value else: - self.st_value = fcurve.getFCurveValues(self.settings["st_profile"], - self.divisions) - self.sq_value = fcurve.getFCurveValues(self.settings["sq_profile"], - self.divisions) - - self.st_att = [self.addSetupParam("stretch_%s" % i, - "Stretch %s" % i, - "double", self.st_value[i], -1, 0) - for i in range(self.divisions)] - self.sq_att = [self.addSetupParam("squash_%s" % i, - "Squash %s" % i, - "double", - self.sq_value[i], 0, 1) - for i in range(self.divisions)] + self.st_value = fcurve.getFCurveValues( + self.settings["st_profile"], self.divisions + ) + self.sq_value = fcurve.getFCurveValues( + self.settings["sq_profile"], self.divisions + ) + + self.st_att = [ + self.addSetupParam( + "stretch_%s" % i, + "Stretch %s" % i, + "double", + self.st_value[i], + -1, + 0, + ) + for i in range(self.divisions) + ] + self.sq_att = [ + self.addSetupParam( + "squash_%s" % i, + "Squash %s" % i, + "double", + self.sq_value[i], + 0, + 1, + ) + for i in range(self.divisions) + ] self.resample_att = self.addSetupParam( - "resample", "Resample", "bool", True) + "resample", "Resample", "bool", True + ) self.absolute_att = self.addSetupParam( - "absolute", "Absolute", "bool", False) + "absolute", "Absolute", "bool", False + ) # ===================================================== # OPERATORS @@ -579,12 +665,12 @@ def addOperators(self): self.root, self.getName("ikHandleLegChainUpvRef"), self.legChainUpvRef, - "ikSCsolver") + "ikSCsolver", + ) pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef) - pm.parentConstraint(self.legChainUpvRef[0], - self.ik_ctl, - self.upv_cns, - mo=True) + pm.parentConstraint( + self.legChainUpvRef[0], self.ik_ctl, self.upv_cns, mo=True + ) # Visibilities ------------------------------------- # shape.dispGeometry @@ -612,16 +698,18 @@ def addOperators(self): # IK Solver ----------------------------------------- out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_loc] - o_node = applyop.gear_ikfk2bone_op(out, - self.root_ctl, - self.ik_ref, - self.upv_ctl, - self.fk_ctl[0], - self.fk_ctl[1], - self.fk_ref, - self.length0, - self.length1, - self.negate) + o_node = applyop.gear_ikfk2bone_op( + out, + self.root_ctl, + self.ik_ref, + self.upv_ctl, + self.fk_ctl[0], + self.fk_ctl[1], + self.fk_ref, + self.length0, + self.length1, + self.negate, + ) pm.connectAttr(self.blend_att, o_node + ".blend") if self.negate: @@ -641,7 +729,8 @@ def addOperators(self): self.getName("legRollRef"), self.rollRef, parent=self.root, - cParent=self.bone0) + cParent=self.bone0, + ) pm.pointConstraint(self.mid_ctl, self.tws1_loc, maintainOffset=False) pm.connectAttr(self.mid_ctl.scaleX, self.tws1_loc.scaleX) @@ -660,26 +749,25 @@ def addOperators(self): applyop.oriCns(ori_ref, self.tws0_loc, maintainOffset=True) - self.tws0_loc.setAttr("sx", .001) - self.tws2_loc.setAttr("sx", .001) + self.tws0_loc.setAttr("sx", 0.001) + self.tws2_loc.setAttr("sx", 0.001) - add_node = node.createAddNode(self.roundness_att, .0) + add_node = node.createAddNode(self.roundness_att, 0.0) pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx")) # Volume ------------------------------------------- distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc) distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc) - add_node = node.createAddNode(distA_node.distance, - distB_node.distance) - div_node = node.createDivNode(add_node.output, - self.root_ctl.attr("sx")) + add_node = node.createAddNode(distA_node.distance, distB_node.distance) + div_node = node.createDivNode( + add_node.output, self.root_ctl.attr("sx") + ) # comp scaling issue dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(self.root.attr("worldMatrix"), dm_node.inputMatrix) - div_node2 = node.createDivNode(div_node.outputX, - dm_node.outputScaleX) + div_node2 = node.createDivNode(div_node.outputX, dm_node.outputScaleX) self.volDriver_att = div_node2.outputX @@ -694,15 +782,15 @@ def addOperators(self): for i, div_cns in enumerate(self.div_cns): subdiv = 40 if i < (self.settings["div0"] + 1): - perc = i * .5 / (self.settings["div0"] + 1.0) + perc = i * 0.5 / (self.settings["div0"] + 1.0) elif i < (self.settings["div0"] + 2): - perc = .501 + perc = 0.501 else: - perc = .5 + \ - (i - self.settings["div0"] - 1.0) * .5 / \ - (self.settings["div1"] + 1.0) + perc = 0.5 + (i - self.settings["div0"] - 1.0) * 0.5 / ( + self.settings["div1"] + 1.0 + ) - perc = max(.001, min(.999, perc)) + perc = max(0.001, min(0.999, perc)) # Roll if self.negate: @@ -710,20 +798,23 @@ def addOperators(self): div_cns, [self.tws2_rot, self.tws1_rot, self.tws0_rot], 1.0 - perc, - subdiv) + subdiv, + ) else: o_node = applyop.gear_rollsplinekine_op( div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot], perc, - subdiv) + subdiv, + ) pm.connectAttr(self.resample_att, o_node.resample) pm.connectAttr(self.absolute_att, o_node.absolute) # Squash n Stretch o_node = applyop.gear_squashstretch2_op( - div_cns, None, pm.getAttr(self.volDriver_att), "x") + div_cns, None, pm.getAttr(self.volDriver_att), "x" + ) pm.connectAttr(self.volume_att, o_node.blend) pm.connectAttr(self.volDriver_att, o_node.driver) pm.connectAttr(self.st_att[i], o_node.stretch) @@ -762,22 +853,26 @@ def connect_standard(self): # Set the Ik Reference self.connectRef(self.settings["ikrefarray"], self.ik_cns) if self.settings["upvrefarray"]: - self.connectRef("Auto,Foot," + self.settings["upvrefarray"], - self.upv_cns, True) + self.connectRef( + "Auto,Foot," + self.settings["upvrefarray"], self.upv_cns, True + ) else: self.connectRef("Auto,Foot", self.upv_cns, True) if self.settings["pinrefarray"]: - self.connectRef2("Auto," + self.settings["pinrefarray"], - self.mid_cns, - self.pin_att, - [self.ctrn_loc], - False) + self.connectRef2( + "Auto," + self.settings["pinrefarray"], + self.mid_cns, + self.pin_att, + [self.ctrn_loc], + False, + ) def collect_build_data(self): component.Main.collect_build_data(self) - self.build_data['DataContracts'] = ["Ik"] - self.build_data['Ik'] = [ + self.build_data["DataContracts"] = ["Ik"] + self.build_data["Ik"] = [ self.jointList[0].name(), self.jointList[self.settings["div0"] + 1].name(), - self.jointList[-1].name()] + self.jointList[-1].name(), + ] diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/guide.py index f2d9be86..31a039cf 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_leg_01/guide.py @@ -1,4 +1,3 @@ - from functools import partial from mgear.shifter.component import guide @@ -17,8 +16,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_leg_01" NAME = "leg" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on leg_2jnt_01" +) ########################################################## # CLASS @@ -49,7 +50,7 @@ def addObjects(self): self.knee = self.addLoc("knee", self.root, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, -6, 0]) self.ankle = self.addLoc("ankle", self.knee, vTemp) - vTemp = transform.getOffsetPosition(self.root, [0, -6, .5]) + vTemp = transform.getOffsetPosition(self.root, [0, -6, 0.5]) self.eff = self.addLoc("eff", self.ankle, vTemp) centers = [self.root, self.knee, self.ankle, self.eff] @@ -74,23 +75,27 @@ def addParameters(self): # FCurves self.pSt_profile = self.addFCurveParam( - "st_profile", [[0, 0], [.5, -.5], [1, 0]]) + "st_profile", [[0, 0], [0.5, -0.5], [1, 0]] + ) self.pSq_profile = self.addFCurveParam( - "sq_profile", [[0, 0], [.5, .5], [1, 0]]) + "sq_profile", [[0, 0], [0.5, 0.5], [1, 0]] + ) self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) def get_divisions(self): - """ Returns correct segments divisions """ + """Returns correct segments divisions""" self.divisions = self.root.div0.get() + self.root.div1.get() + 3 return self.divisions + ########################################################## # Setting Page ########################################################## @@ -144,18 +149,22 @@ def populate_componentControls(self): # populate component settings self.settingsTab.ikfk_slider.setValue( - int(self.root.attr("blend").get() * 100)) + int(self.root.attr("blend").get() * 100) + ) self.settingsTab.ikfk_spinBox.setValue( - int(self.root.attr("blend").get() * 100)) + int(self.root.attr("blend").get() * 100) + ) self.settingsTab.maxStretch_spinBox.setValue( - self.root.attr("maxstretch").get()) + self.root.attr("maxstretch").get() + ) self.populateCheck(self.settingsTab.mirrorMid_checkBox, "mirrorMid") self.populateCheck(self.settingsTab.extraTweak_checkBox, "extraTweak") - self.populateCheck(self.settingsTab.TPoseRest_checkBox, - "FK_rest_T_Pose") + self.populateCheck( + self.settingsTab.TPoseRest_checkBox, "FK_rest_T_Pose" + ) self.settingsTab.div0_spinBox.setValue(self.root.attr("div0").get()) self.settingsTab.div1_spinBox.setValue(self.root.attr("div1").get()) ikRefArrayItems = self.root.attr("ikrefarray").get().split(",") @@ -179,88 +188,134 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.ikfk_slider.valueChanged.connect( - partial(self.updateSlider, self.settingsTab.ikfk_slider, "blend")) + partial(self.updateSlider, self.settingsTab.ikfk_slider, "blend") + ) self.settingsTab.ikfk_spinBox.valueChanged.connect( - partial(self.updateSlider, self.settingsTab.ikfk_spinBox, "blend")) + partial(self.updateSlider, self.settingsTab.ikfk_spinBox, "blend") + ) self.settingsTab.maxStretch_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxStretch_spinBox, - "maxstretch")) + partial( + self.updateSpinBox, + self.settingsTab.maxStretch_spinBox, + "maxstretch", + ) + ) self.settingsTab.div0_spinBox.valueChanged.connect( - partial(self.updateSpinBox, self.settingsTab.div0_spinBox, "div0")) + partial(self.updateSpinBox, self.settingsTab.div0_spinBox, "div0") + ) self.settingsTab.div1_spinBox.valueChanged.connect( - partial(self.updateSpinBox, self.settingsTab.div1_spinBox, "div1")) + partial(self.updateSpinBox, self.settingsTab.div1_spinBox, "div1") + ) self.settingsTab.squashStretchProfile_pushButton.clicked.connect( - self.setProfile) + self.setProfile + ) self.settingsTab.mirrorMid_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.mirrorMid_checkBox, - "mirrorMid")) + partial( + self.updateCheck, + self.settingsTab.mirrorMid_checkBox, + "mirrorMid", + ) + ) self.settingsTab.extraTweak_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.extraTweak_checkBox, "extraTweak")) + partial( + self.updateCheck, + self.settingsTab.extraTweak_checkBox, + "extraTweak", + ) + ) self.settingsTab.TPoseRest_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.TPoseRest_checkBox, "FK_rest_T_Pose")) + partial( + self.updateCheck, + self.settingsTab.TPoseRest_checkBox, + "FK_rest_T_Pose", + ) + ) self.settingsTab.ikRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.upvRefArray_listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.upvRefArray_listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_listWidget.installEventFilter(self) self.settingsTab.upvRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArray_listWidget.installEventFilter(self) self.settingsTab.pinRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArray_listWidget.installEventFilter(self) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/__init__.py index 57526de2..32b0b0c7 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/__init__.py @@ -1,4 +1,3 @@ - import pymel.core as pm from pymel.core import datatypes @@ -30,28 +29,37 @@ def addObjects(self): 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]) + 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) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[0], + self.guide.apos[1], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: x = datatypes.Vector(1, 0, 0) @@ -70,92 +78,106 @@ def addObjects(self): else: t_npo = t - self.fk0_npo = primitive.addTransform(self.root, - self.getName("fk0_npo"), - t_npo) - 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) + self.fk0_npo = primitive.addTransform( + self.root, self.getName("fk0_npo"), t_npo + ) + vec_po = datatypes.Vector(0.5 * self.length0 * self.n_factor, 0, 0) + self.fk0_ctl = self.addCtl( + self.fk0_npo, + "fk0_ctl", + t, + self.color_fk, + "cube", + w=self.length0, + h=self.size * 0.1, + d=self.size * 0.1, + po=vec_po, + tp=self.parentCtlTag, + ) attribute.setKeyableAttributes( - self.fk0_ctl, - ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[1], + self.guide.apos[2], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk0_ctl), self.guide.apos[1]) + transform.getTransform(self.fk0_ctl), self.guide.apos[1] + ) else: t_npo = t - self.fk1_npo = primitive.addTransform(self.fk0_ctl, - self.getName("fk1_npo"), - t_npo) - - vec_po = datatypes.Vector(.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) + self.fk1_npo = primitive.addTransform( + self.fk0_ctl, self.getName("fk1_npo"), t_npo + ) + + vec_po = datatypes.Vector(0.5 * self.length1 * self.n_factor, 0, 0) + self.fk1_ctl = self.addCtl( + self.fk1_npo, + "fk1_ctl", + t, + self.color_fk, + "cube", + w=self.length1, + h=self.size * 0.1, + d=self.size * 0.1, + po=vec_po, + tp=self.fk0_ctl, + ) attribute.setKeyableAttributes( - self.fk1_ctl, - ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"] + ) if self.settings["use_blade"]: - t = transform.getTransformLookingAt(self.guide.apos[2], - self.guide.apos[3], - self.blade_normal, - "x-z", - self.negate) + t = transform.getTransformLookingAt( + self.guide.apos[2], + self.guide.apos[3], + self.blade_normal, + "x-z", + self.negate, + ) else: - t = transform.getTransformLookingAt(self.guide.apos[2], - self.guide.apos[3], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.apos[2], + self.guide.apos[3], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk1_ctl), self.guide.apos[2]) + transform.getTransform(self.fk1_ctl), self.guide.apos[2] + ) else: t_npo = t - self.fk2_npo = primitive.addTransform(self.fk1_ctl, - self.getName("fk2_npo"), - t_npo) - - vec_po = datatypes.Vector(.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) + self.fk2_npo = primitive.addTransform( + self.fk1_ctl, self.getName("fk2_npo"), t_npo + ) + + vec_po = datatypes.Vector(0.5 * self.length2 * self.n_factor, 0, 0) + self.fk2_ctl = self.addCtl( + self.fk2_npo, + "fk2_ctl", + t, + self.color_fk, + "cube", + w=self.length2, + h=self.size * 0.1, + d=self.size * 0.1, + po=vec_po, + tp=self.fk1_ctl, + ) attribute.setKeyableAttributes(self.fk2_ctl) @@ -170,44 +192,49 @@ def addObjects(self): self.tip_ref = primitive.addTransform( self.armChainUpvRef[0], self.getName("tip_ref"), - self.armChainUpvRef[0].getMatrix(worldSpace=True)) + 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)) + 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)) + 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) + self.roll_ctl = self.addCtl( + self.roll_ctl_npo, + "roll_ctl", + transform.getTransform(self.roll_ctl_npo), + self.color_ik, + "compas", + w=self.size * 0.3, + ro=datatypes.Vector([off_x, off_y, 0]), + tp=self.parentCtlTag, + ) attribute.setKeyableAttributes(self.roll_ctl, ["rx"]) # create upv control v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() - v *= self.size * .8 + v *= self.size * 0.8 v += self.guide.apos[1] - self.upv_cns = primitive.addTransformFromPos(self.root, - self.getName("upv_cns"), - v) + self.upv_cns = primitive.addTransformFromPos( + self.root, self.getName("upv_cns"), v + ) self.upv_ctl = self.addCtl( self.upv_cns, @@ -215,8 +242,9 @@ def addObjects(self): transform.getTransform(self.upv_cns), self.color_ik, "diamond", - w=self.size * .12, - tp=self.parentCtlTag) + w=self.size * 0.12, + tp=self.parentCtlTag, + ) if self.settings["mirrorMid"]: if self.negate: @@ -229,16 +257,19 @@ def addObjects(self): # IK Controlers ----------------------------------- self.ik_cns = primitive.addTransformFromPos( - self.root, self.getName("ik_cns"), self.guide.pos["wrist"]) + self.root, self.getName("ik_cns"), self.guide.pos["wrist"] + ) t = transform.getTransformFromPos(self.guide.pos["wrist"]) - self.ikcns_ctl = self.addCtl(self.ik_cns, - "ikcns_ctl", - t, - self.color_ik, - "null", - w=self.size * .12, - tp=self.parentCtlTag) + self.ikcns_ctl = self.addCtl( + self.ik_cns, + "ikcns_ctl", + t, + self.color_ik, + "null", + w=self.size * 0.12, + tp=self.parentCtlTag, + ) attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"]) @@ -253,28 +284,34 @@ def addObjects(self): if self.negate: - m = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - normal, - axis_ref1, - True) + m = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + normal, + axis_ref1, + True, + ) else: - m = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - normal, - axis_ref2, - False) - - self.ik_ctl = self.addCtl(self.ikcns_ctl, - "ik_ctl", - m, - self.color_ik, - "cube", - w=self.size * .12, - h=self.size * .12, - d=self.size * .12, - tp=self.roll_ctl) + m = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + normal, + axis_ref2, + False, + ) + + self.ik_ctl = self.addCtl( + self.ikcns_ctl, + "ik_ctl", + m, + self.color_ik, + "cube", + w=self.size * 0.12, + h=self.size * 0.12, + d=self.size * 0.12, + tp=self.roll_ctl, + ) if self.settings["mirrorIK"]: if self.negate: @@ -284,25 +321,27 @@ def addObjects(self): 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) + 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) + self.ikRot_npo = primitive.addTransform( + self.root, self.getName("ikRot_npo"), m + ) + self.ikRot_cns = primitive.addTransform( + self.ikRot_npo, self.getName("ikRot_cns"), m + ) + self.ikRot_ctl = self.addCtl( + self.ikRot_cns, + "ikRot_ctl", + m, + self.color_ik, + "sphere", + w=self.size * 0.12, + tp=self.ik_ctl, + ) attribute.setKeyableAttributes(self.ikRot_ctl, self.r_params) @@ -315,53 +354,59 @@ def addObjects(self): else: normal = self.normal axis_ref = "xz" - trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - normal, - axis_ref, - self.negate) - - self.ik_ref = primitive.addTransform(self.ik_ctl_ref, - self.getName("ik_ref"), - trnIK_ref) - self.fk_ref = primitive.addTransform(self.fk_ctl[2], - self.getName("fk_ref"), - trnIK_ref) + trnIK_ref = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + normal, + axis_ref, + self.negate, + ) + + self.ik_ref = primitive.addTransform( + self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref + ) + self.fk_ref = primitive.addTransform( + self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref + ) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root, self.getName("0_bone"), - transform.getTransform(self.fk_ctl[0])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone0_shp.setAttr("localScale", 0.5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root, self.getName("1_bone"), - transform.getTransform(self.fk_ctl[1])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone1_shp.setAttr("localScale", 0.5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) - self.ctrn_loc = primitive.addTransformFromPos(self.root, - self.getName("ctrn_loc"), - self.guide.apos[1]) - self.eff_loc = primitive.addTransformFromPos(self.root, - self.getName("eff_loc"), - self.guide.apos[2]) + 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] + ) # set the offset rotation for the hand - self.off_t = transform.getTransformLookingAt(self.guide.pos["wrist"], - self.guide.pos["eff"], - self.blade_normal, - axis="xy", - negate=self.negate) + self.off_t = transform.getTransformLookingAt( + self.guide.pos["wrist"], + self.guide.pos["eff"], + self.blade_normal, + axis="xy", + negate=self.negate, + ) if self.settings["use_blade"]: # set the offset rotation for the hand self.off_t = transform.getTransformLookingAt( @@ -369,96 +414,104 @@ def addObjects(self): self.guide.pos["eff"], self.blade_normal, axis="xy", - negate=self.negate) + negate=self.negate, + ) self.eff_jnt_off = primitive.addTransform( - self.eff_loc, - self.getName("eff_off"), - self.off_t) + self.eff_loc, self.getName("eff_off"), self.off_t + ) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) - self.mid_cns = primitive.addTransform(self.ctrn_loc, - self.getName("mid_cns"), - t) + self.mid_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) + self.mid_ctl = self.addCtl( + self.mid_cns, + "mid_ctl", + t, + self.color_ik, + "sphere", + w=self.size * 0.2, + tp=self.parentCtlTag, + ) - attribute.setKeyableAttributes(self.mid_ctl, - params=["tx", "ty", "tz", - "ro", "rx", "ry", "rz", - "sx"]) + 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, self.getName("mid_twst_npo"), t + ) self.mid_ctl_twst_ref = primitive.addTransform( - self.mid_ctl_twst_npo, - self.getName("mid_twst_ref"), - t) + 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) - t = transform.getTransformLookingAt(self.guide.pos["base"], - self.guide.apos[1], - self.normal, - "xz", - self.negate) + self.rollRef = primitive.add2DChain( + self.root, + self.getName("rollChain"), + self.guide.apos[:2], + self.normal, + self.negate, + ) + t = transform.getTransformLookingAt( + self.guide.pos["base"], + self.guide.apos[1], + self.normal, + "xz", + self.negate, + ) for x in self.rollRef: x.setAttr("visibility", False) self.tws0_loc = primitive.addTransform( - self.root, - self.getName("tws0_loc"), - t) + self.root, self.getName("tws0_loc"), t + ) self.tws0_rot = primitive.addTransform( - self.tws0_loc, - self.getName("tws0_rot"), - t) + self.tws0_loc, self.getName("tws0_rot"), t + ) self.tws1_npo = primitive.addTransform( self.ctrn_loc, self.getName("tws1_npo"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws1_loc = primitive.addTransform( self.tws1_npo, self.getName("tws1_loc"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws2_npo = primitive.addTransform( self.root, self.getName("tws2_npo"), - transform.getTransform(self.fk_ctl[2])) + transform.getTransform(self.fk_ctl[2]), + ) self.tws2_loc = primitive.addTransform( self.tws2_npo, self.getName("tws2_loc"), - transform.getTransform(self.fk_ctl[2])) + transform.getTransform(self.fk_ctl[2]), + ) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), - transform.getTransform(self.fk_ctl[2])) + transform.getTransform(self.fk_ctl[2]), + ) # Divisions ---------------------------------------- @@ -472,22 +525,25 @@ def addObjects(self): for i in range(self.divisions): - div_cns = primitive.addTransform(self.root, - self.getName("div%s_loc" % i)) + 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) + tweak_ctl = self.addCtl( + div_cns, + "tweak%s_ctl" % i, + t, + self.color_fk, + "square", + w=self.size * 0.15, + d=self.size * 0.15, + ro=datatypes.Vector([0, 0, 1.5708]), + tp=tagP, + ) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl @@ -511,60 +567,60 @@ def addObjects(self): increment = -1 else: self.jnt_pos.append( - [driver, - twist_name + str(twist_idx).zfill(2), - current_parent]) + [ + driver, + twist_name + str(twist_idx).zfill(2), + current_parent, + ] + ) twist_idx += increment if self.settings["use_blade"]: eff_loc = self.eff_jnt_off else: eff_loc = self.eff_loc - self.jnt_pos.append([eff_loc, 'hand', current_parent]) + self.jnt_pos.append([eff_loc, "hand", current_parent]) # match IK FK references - self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], - self.root, - "matchFk0_npo", - False) + self.match_fk0_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_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_off = self.add_match_ref( + self.fk_ctl[2], self.root, "matchFk1_npo", False + ) - self.match_fk1 = self.add_match_ref(self.fk_ctl[1], - self.match_fk1_off, - "fk1_mth") + self.match_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") + 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_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_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") + 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]) + self.getName("visalRef"), [self.upv_ctl, self.mid_ctl] + ) # ===================================================== # ATTRIBUTES @@ -573,113 +629,89 @@ def addAttributes(self): """Create the anim and setupr rig attributes for the component""" # Anim ------------------------------------------- - self.blend_att = self.addAnimParam("blend", - "Fk/Ik Blend", - "double", - self.settings["blend"], - 0, - 1) - self.roll_att = self.addAnimParam("roll", - "Roll", - "double", - 0, - -180, - 180) - self.armpit_roll_att = self.addAnimParam("aproll", - "Armpit Roll", - "double", - 0, - -360, - 360) - - self.scale_att = self.addAnimParam("ikscale", - "Scale", - "double", - 1, - .001, - 99) - self.maxstretch_att = self.addAnimParam("maxstretch", - "Max Stretch", - "double", - self.settings["maxstretch"], - 1, - 99) - self.slide_att = self.addAnimParam("slide", - "Slide", - "double", - .5, - 0, - 1) - self.softness_att = self.addAnimParam("softness", - "Softness", - "double", - 0, - 0, - 1) - self.reverse_att = self.addAnimParam("reverse", - "Reverse", - "double", - 0, - 0, - 1) - self.roundness_att = self.addAnimParam("roundness", - "Roundness", - "double", - 0, - 0, - self.size) - self.volume_att = self.addAnimParam("volume", - "Volume", - "double", - 1, - 0, - 1) + self.blend_att = self.addAnimParam( + "blend", "Fk/Ik Blend", "double", self.settings["blend"], 0, 1 + ) + self.roll_att = self.addAnimParam( + "roll", "Roll", "double", 0, -180, 180 + ) + self.armpit_roll_att = self.addAnimParam( + "aproll", "Armpit Roll", "double", 0, -360, 360 + ) + + self.scale_att = self.addAnimParam( + "ikscale", "Scale", "double", 1, 0.001, 99 + ) + self.maxstretch_att = self.addAnimParam( + "maxstretch", + "Max Stretch", + "double", + self.settings["maxstretch"], + 1, + 99, + ) + self.slide_att = self.addAnimParam( + "slide", "Slide", "double", 0.5, 0, 1 + ) + self.softness_att = self.addAnimParam( + "softness", "Softness", "double", 0, 0, 1 + ) + self.reverse_att = self.addAnimParam( + "reverse", "Reverse", "double", 0, 0, 1 + ) + self.roundness_att = self.addAnimParam( + "roundness", "Roundness", "double", 0, 0, self.size + ) + self.volume_att = self.addAnimParam( + "volume", "Volume", "double", 1, 0, 1 + ) if self.settings["extraTweak"]: self.tweakVis_att = self.addAnimParam( - "Tweak_vis", "Tweak Vis", "bool", False) + "Tweak_vis", "Tweak Vis", "bool", False + ) # Ref if self.settings["ikrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) if len(ref_names) > 1: self.ikref_att = self.addAnimEnumParam( - "ikref", - "Ik Ref", - 0, - ref_names) + "ikref", "Ik Ref", 0, ref_names + ) if self.settings["ikTR"]: ref_names = ["Auto", "ik_ctl"] if self.settings["ikrefarray"]: ref_names = ref_names + self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) - self.ikRotRef_att = self.addAnimEnumParam("ikRotRef", - "Ik Rot Ref", - 0, - ref_names) + self.ikRotRef_att = self.addAnimEnumParam( + "ikRotRef", "Ik Rot Ref", 0, ref_names + ) if self.settings["upvrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["upvrefarray"].split(",")) + self.settings["upvrefarray"].split(",") + ) ref_names = ["Auto"] + ref_names if len(ref_names) > 1: - self.upvref_att = self.addAnimEnumParam("upvref", - "UpV Ref", - 0, ref_names) + self.upvref_att = self.addAnimEnumParam( + "upvref", "UpV Ref", 0, ref_names + ) if self.settings["pinrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["pinrefarray"].split(",")) + self.settings["pinrefarray"].split(",") + ) ref_names = ["Auto"] + ref_names if len(ref_names) > 1: - self.pin_att = self.addAnimEnumParam("elbowref", - "Elbow Ref", - 0, - ref_names) + self.pin_att = self.addAnimEnumParam( + "elbowref", "Elbow Ref", 0, ref_names + ) if self.validProxyChannels: attrs_list = [self.blend_att, self.roundness_att] @@ -687,14 +719,18 @@ def addAttributes(self): attrs_list += [self.tweakVis_att] attribute.addProxyAttribute( attrs_list, - [self.fk0_ctl, + [ + self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.ik_ctl, self.upv_ctl, - self.mid_ctl]) - attribute.addProxyAttribute(self.roll_att, - [self.ik_ctl, self.upv_ctl]) + self.mid_ctl, + ], + ) + attribute.addProxyAttribute( + self.roll_att, [self.ik_ctl, self.upv_ctl] + ) # Setup ------------------------------------------ # Eval Fcurve @@ -702,34 +738,43 @@ def addAttributes(self): self.st_value = self.guide.paramDefs["st_profile"].value self.sq_value = self.guide.paramDefs["sq_profile"].value else: - self.st_value = fcurve.getFCurveValues(self.settings["st_profile"], - self.divisions) - self.sq_value = fcurve.getFCurveValues(self.settings["sq_profile"], - self.divisions) - - self.st_att = [self.addSetupParam("stretch_%s" % i, - "Stretch %s" % i, - "double", self.st_value[i], - -1, - 0) - for i in range(self.divisions)] - - self.sq_att = [self.addSetupParam("squash_%s" % i, - "Squash %s" % i, - "double", - self.sq_value[i], - 0, - 1) - for i in range(self.divisions)] - - self.resample_att = self.addSetupParam("resample", - "Resample", - "bool", - True) - self.absolute_att = self.addSetupParam("absolute", - "Absolute", - "bool", - False) + self.st_value = fcurve.getFCurveValues( + self.settings["st_profile"], self.divisions + ) + self.sq_value = fcurve.getFCurveValues( + self.settings["sq_profile"], self.divisions + ) + + self.st_att = [ + self.addSetupParam( + "stretch_%s" % i, + "Stretch %s" % i, + "double", + self.st_value[i], + -1, + 0, + ) + for i in range(self.divisions) + ] + + self.sq_att = [ + self.addSetupParam( + "squash_%s" % i, + "Squash %s" % i, + "double", + self.sq_value[i], + 0, + 1, + ) + for i in range(self.divisions) + ] + + self.resample_att = self.addSetupParam( + "resample", "Resample", "bool", True + ) + self.absolute_att = self.addSetupParam( + "absolute", "Absolute", "bool", False + ) # ===================================================== # OPERATORS @@ -747,12 +792,12 @@ def addOperators(self): self.root, self.getName("ikHandleArmChainUpvRef"), self.armChainUpvRef, - "ikSCsolver") - pm.pointConstraint(self.ik_ctl, - self.ikHandleUpvRef) - p_cns = pm.parentConstraint(self.armChainUpvRef[0], - self.upv_cns, - mo=True) + "ikSCsolver", + ) + pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef) + p_cns = pm.parentConstraint( + self.armChainUpvRef[0], self.upv_cns, mo=True + ) p_cns.interpType.set(0) # Visibilities ------------------------------------- @@ -791,16 +836,18 @@ def addOperators(self): # IK Solver ----------------------------------------- out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_loc] - o_node = applyop.gear_ikfk2bone_op(out, - self.root, - self.ik_ref, - self.upv_ctl, - self.fk_ctl[0], - self.fk_ctl[1], - self.fk_ref, - self.length0, - self.length1, - self.negate) + o_node = applyop.gear_ikfk2bone_op( + out, + self.root, + self.ik_ref, + self.upv_ctl, + self.fk_ctl[0], + self.fk_ctl[1], + self.fk_ref, + self.length0, + self.length1, + self.negate, + ) # NOTE: Ideally we should not change hierarchy or move object after # object generation method. But is much easier this way since every @@ -814,11 +861,13 @@ def addOperators(self): int_matrix = applyop.gear_intmatrix_op( self.armChainUpvRef[0].attr("worldMatrix"), self.tip_ref.attr("worldMatrix"), - .5) + 0.5, + ) applyop.gear_mulmatrix_op( int_matrix.attr("output"), self.interpolate_lvl.attr("parentInverseMatrix[0]"), - self.interpolate_lvl) + self.interpolate_lvl, + ) # match roll ctl npo to ctrn_loc current transform (so correct orient) transform.matchWorldTransform(self.ctrn_loc, self.roll_ctl_npo) @@ -844,10 +893,13 @@ def addOperators(self): # rotation mulM_node = applyop.gear_mulmatrix_op( self.ikRot_ctl.attr("worldMatrix"), - self.eff_loc.attr("parentInverseMatrix")) - intM_node = applyop.gear_intmatrix_op(o_node.attr("outEff"), - mulM_node.attr("output"), - o_node.attr("blend")) + self.eff_loc.attr("parentInverseMatrix"), + ) + intM_node = applyop.gear_intmatrix_op( + o_node.attr("outEff"), + mulM_node.attr("output"), + o_node.attr("blend"), + ) dm_node = node.createDecomposeMatrixNode(intM_node.attr("output")) dm_node.attr("outputRotate") >> self.eff_loc.attr("rotate") transform.matchWorldTransform(self.fk2_ctl, self.ikRot_cns) @@ -856,10 +908,11 @@ def addOperators(self): intM_node = applyop.gear_intmatrix_op( self.fk2_ctl.attr("worldMatrix"), self.ik_ctl_ref.attr("worldMatrix"), - o_node.attr("blend")) + o_node.attr("blend"), + ) mulM_node = applyop.gear_mulmatrix_op( - intM_node.attr("output"), - self.eff_loc.attr("parentInverseMatrix")) + intM_node.attr("output"), self.eff_loc.attr("parentInverseMatrix") + ) dm_node = node.createDecomposeMatrixNode(mulM_node.attr("output")) dm_node.attr("outputScale") >> self.eff_loc.attr("scale") @@ -870,14 +923,13 @@ def addOperators(self): else: mulVal = 1 rollMulVal = -1 - roll_m_node = node.createMulNode(self.roll_att, - mulVal) - roll_m_node2 = node.createMulNode(self.roll_ctl.attr("rx"), - rollMulVal) + roll_m_node = node.createMulNode(self.roll_att, mulVal) + roll_m_node2 = node.createMulNode(self.roll_ctl.attr("rx"), rollMulVal) node.createPlusMinusAverage1D( [roll_m_node.outputX, roll_m_node2.outputX], operation=1, - output=o_node + ".roll") + output=o_node + ".roll", + ) pm.connectAttr(self.scale_att, o_node + ".scaleA") pm.connectAttr(self.scale_att, o_node + ".scaleB") pm.connectAttr(self.maxstretch_att, o_node + ".maxstretch") @@ -887,18 +939,23 @@ def addOperators(self): # Twist references --------------------------------- - pm.pointConstraint(self.mid_ctl_twst_ref, - self.tws1_npo, maintainOffset=False) + pm.pointConstraint( + self.mid_ctl_twst_ref, self.tws1_npo, maintainOffset=False + ) pm.connectAttr(self.mid_ctl.scaleX, self.tws1_loc.scaleX) - pm.orientConstraint(self.mid_ctl_twst_ref, - self.tws1_npo, maintainOffset=False) + pm.orientConstraint( + self.mid_ctl_twst_ref, self.tws1_npo, maintainOffset=False + ) - o_node = applyop.gear_mulmatrix_op(self.eff_loc.attr( - "worldMatrix"), self.root.attr("worldInverseMatrix")) + o_node = applyop.gear_mulmatrix_op( + self.eff_loc.attr("worldMatrix"), + self.root.attr("worldInverseMatrix"), + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix") - pm.connectAttr(dm_node + ".outputTranslate", - self.tws2_npo.attr("translate")) + pm.connectAttr( + dm_node + ".outputTranslate", self.tws2_npo.attr("translate") + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix") @@ -906,7 +963,8 @@ def addOperators(self): o_node = applyop.gear_mulmatrix_op( self.eff_loc.attr("worldMatrix"), - self.tws2_rot.attr("parentInverseMatrix")) + self.tws2_rot.attr("parentInverseMatrix"), + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(o_node + ".output", dm_node + ".inputMatrix") attribute.setRotOrder(self.tws2_rot, "XYZ") @@ -919,31 +977,38 @@ def addOperators(self): applyop.oriCns(ori_ref, self.tws0_loc, maintainOffset=True) - self.tws0_rot.setAttr("sx", .001) - self.tws2_rot.setAttr("sx", .001) + self.tws0_rot.setAttr("sx", 0.001) + self.tws2_rot.setAttr("sx", 0.001) - add_node = node.createAddNode(self.roundness_att, .0) + add_node = node.createAddNode(self.roundness_att, 0.0) pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx")) pm.connectAttr(self.armpit_roll_att, self.tws0_rot + ".rotateX") # Roll Shoulder - applyop.splineIK(self.getName("rollRef"), self.rollRef, - parent=self.root, cParent=self.bone0) + applyop.splineIK( + self.getName("rollRef"), + self.rollRef, + parent=self.root, + cParent=self.bone0, + ) # Volume ------------------------------------------- distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc) distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc) - add_node = node.createAddNode(distA_node + ".distance", - distB_node + ".distance") - div_node = node.createDivNode(add_node + ".output", - self.root.attr("sx")) + add_node = node.createAddNode( + distA_node + ".distance", distB_node + ".distance" + ) + div_node = node.createDivNode( + add_node + ".output", self.root.attr("sx") + ) dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(self.root.attr("worldMatrix"), dm_node + ".inputMatrix") - div_node2 = node.createDivNode(div_node + ".outputX", - dm_node + ".outputScaleX") + div_node2 = node.createDivNode( + div_node + ".outputX", dm_node + ".outputScaleX" + ) self.volDriver_att = div_node2 + ".outputX" if self.settings["extraTweak"]: @@ -957,32 +1022,39 @@ def addOperators(self): for i, div_cns in enumerate(self.div_cns): if i < (self.settings["div0"] + 1): - perc = i * .5 / (self.settings["div0"] + 1.0) + perc = i * 0.5 / (self.settings["div0"] + 1.0) elif i < (self.settings["div0"] + 2): - perc = .501 + perc = 0.501 else: - perc = .5 + \ - (i - self.settings["div0"] - 1.0) * .5 / \ - (self.settings["div1"] + 1.0) + perc = 0.5 + (i - self.settings["div0"] - 1.0) * 0.5 / ( + self.settings["div1"] + 1.0 + ) - perc = max(.0001, min(.999, perc)) + perc = max(0.0001, min(0.999, perc)) # Roll if self.negate: o_node = applyop.gear_rollsplinekine_op( - div_cns, [self.tws2_rot, self.tws1_rot, self.tws0_rot], - 1.0 - perc, 40) + div_cns, + [self.tws2_rot, self.tws1_rot, self.tws0_rot], + 1.0 - perc, + 40, + ) else: o_node = applyop.gear_rollsplinekine_op( - div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot], - perc, 40) + div_cns, + [self.tws0_rot, self.tws1_rot, self.tws2_rot], + perc, + 40, + ) pm.connectAttr(self.resample_att, o_node + ".resample") pm.connectAttr(self.absolute_att, o_node + ".absolute") # Squash n Stretch o_node = applyop.gear_squashstretch2_op( - div_cns, None, pm.getAttr(self.volDriver_att), "x") + div_cns, None, pm.getAttr(self.volDriver_att), "x" + ) pm.connectAttr(self.volume_att, o_node + ".blend") pm.connectAttr(self.volDriver_att, o_node + ".driver") pm.connectAttr(self.st_att[i], o_node + ".stretch") @@ -1043,35 +1115,37 @@ def connect_standard(self): self.connectRef(self.settings["upvrefarray"], self.upv_cns, True) init_refNames = ["lower_arm", "ik_ctl"] - self.connectRef2(self.settings["ikrefarray"], - self.ikRot_cns, - self.ikRotRef_att, - [self.ikRot_npo, self.ik_ctl], - True, - init_refNames) + self.connectRef2( + self.settings["ikrefarray"], + self.ikRot_cns, + self.ikRotRef_att, + [self.ikRot_npo, self.ik_ctl], + True, + init_refNames, + ) else: self.connect_standardWithIkRef() if self.settings["pinrefarray"]: - self.connectRef2(self.settings["pinrefarray"], - self.mid_cns, - self.pin_att, - [self.ctrn_loc], - False, - ["Auto"]) + self.connectRef2( + self.settings["pinrefarray"], + self.mid_cns, + self.pin_att, + [self.ctrn_loc], + False, + ["Auto"], + ) def connect_shoulder_01(self): - """ Custom connection to be use with shoulder 01 component""" + """Custom connection to be use with shoulder 01 component""" self.connect_standard() - pm.parent(self.rollRef[0], - self.ikHandleUpvRef, - self.parent_comp.ctl) + pm.parent(self.rollRef[0], self.ikHandleUpvRef, self.parent_comp.ctl) def collect_build_data(self): component.Main.collect_build_data(self) - self.build_data['DataContracts'] = ["ik"] - self.build_data['ik'] = [ + self.build_data["DataContracts"] = ["ik"] + self.build_data["ik"] = [ self.jointList[0].name(), self.jointList[self.settings["div0"] + 1].name(), - self.jointList[-1].name() + self.jointList[-1].name(), ] diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/guide.py index 6ca01b7c..a28a7d66 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_arm_01/guide.py @@ -1,4 +1,3 @@ - from functools import partial import pymel.core as pm @@ -18,8 +17,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_mannequin_arm_01" NAME = "arm" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on arm_2jnt_02" +) ########################################################## @@ -52,7 +53,7 @@ def addObjects(self): self.root = self.addRoot() - vTemp = transform.getOffsetPosition(self.root, [3, 0, -.01]) + vTemp = transform.getOffsetPosition(self.root, [3, 0, -0.01]) self.elbow = self.addLoc("elbow", self.root, vTemp) vTemp = transform.getOffsetPosition(self.root, [6, 0, 0]) self.wrist = self.addLoc("wrist", self.elbow, vTemp) @@ -63,8 +64,8 @@ def addObjects(self): self.base = self.addLoc("base", self.root, vTemp) self.dispcrv = self.addDispCurve( - "crv", - [self.root, self.elbow, self.wrist, self.eff]) + "crv", [self.root, self.elbow, self.wrist, self.eff] + ) centers = [self.elbow, self.base] self.dispcrv = self.addDispCurve("crv1", centers) @@ -91,20 +92,20 @@ def addParameters(self): self.pDiv1 = self.addParam("div1", "long", 2, 0, None) # FCurves - self.pSt_profile = self.addFCurveParam("st_profile", - [[0, 0], [.5, -.5], [1, 0]]) - self.pSq_profile = self.addFCurveParam("sq_profile", - [[0, 0], [.5, .5], [1, 0]]) + self.pSt_profile = self.addFCurveParam( + "st_profile", [[0, 0], [0.5, -0.5], [1, 0]] + ) + self.pSq_profile = self.addFCurveParam( + "sq_profile", [[0, 0], [0.5, 0.5], [1, 0]] + ) self.pUseIndex = self.addParam("useIndex", "bool", False) - self.pParentJointIndex = self.addParam("parentJointIndex", - "long", - -1, - None, - None) + self.pParentJointIndex = self.addParam( + "parentJointIndex", "long", -1, None, None + ) def get_divisions(self): - """ Returns correct segments divisions """ + """Returns correct segments divisions""" self.divisions = self.root.div0.get() + self.root.div1.get() + 3 @@ -121,6 +122,7 @@ def postDraw(self): # Setting Page ########################################################## + class settingsTab(QtWidgets.QDialog, sui.Ui_Form): """The Component settings UI""" @@ -169,17 +171,21 @@ def populate_componentControls(self): # populate component settings self.settingsTab.ikfk_slider.setValue( - int(self.root.attr("blend").get() * 100)) + int(self.root.attr("blend").get() * 100) + ) self.settingsTab.ikfk_spinBox.setValue( - int(self.root.attr("blend").get() * 100)) + int(self.root.attr("blend").get() * 100) + ) self.settingsTab.maxStretch_spinBox.setValue( - self.root.attr("maxstretch").get()) + self.root.attr("maxstretch").get() + ) self.populateCheck(self.settingsTab.ikTR_checkBox, "ikTR") self.populateCheck(self.settingsTab.mirrorMid_checkBox, "mirrorMid") self.populateCheck(self.settingsTab.mirrorIK_checkBox, "mirrorIK") self.populateCheck(self.settingsTab.extraTweak_checkBox, "extraTweak") - self.populateCheck(self.settingsTab.TPoseRest_checkBox, - "FK_rest_T_Pose") + self.populateCheck( + self.settingsTab.TPoseRest_checkBox, "FK_rest_T_Pose" + ) self.populateCheck(self.settingsTab.useBlade_checkBox, "use_blade") self.settingsTab.div0_spinBox.setValue(self.root.attr("div0").get()) self.settingsTab.div1_spinBox.setValue(self.root.attr("div1").get()) @@ -200,8 +206,9 @@ def populate_componentControls(self): self.c_box = self.mainSettingsTab.connector_comboBox for cnx in Guide.connectors: self.c_box.addItem(cnx) - self.connector_items = [self.c_box.itemText(i) for i in - range(self.c_box.count())] + self.connector_items = [ + self.c_box.itemText(i) for i in range(self.c_box.count()) + ] currentConnector = self.root.attr("connector").get() if currentConnector not in self.connector_items: @@ -209,7 +216,8 @@ def populate_componentControls(self): self.connector_items.append(currentConnector) pm.displayWarning( "The current connector: %s, is not a valid connector for this" - " component. Build will Fail!!") + " component. Build will Fail!!" + ) comboIndex = self.connector_items.index(currentConnector) self.c_box.setCurrentIndex(comboIndex) @@ -224,106 +232,165 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.ikfk_slider.valueChanged.connect( - partial(self.updateSlider, self.settingsTab.ikfk_slider, "blend")) + partial(self.updateSlider, self.settingsTab.ikfk_slider, "blend") + ) self.settingsTab.ikfk_spinBox.valueChanged.connect( - partial(self.updateSlider, self.settingsTab.ikfk_spinBox, "blend")) + partial(self.updateSlider, self.settingsTab.ikfk_spinBox, "blend") + ) self.settingsTab.maxStretch_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxStretch_spinBox, "maxstretch")) + partial( + self.updateSpinBox, + self.settingsTab.maxStretch_spinBox, + "maxstretch", + ) + ) self.settingsTab.div0_spinBox.valueChanged.connect( - partial(self.updateSpinBox, self.settingsTab.div0_spinBox, "div0")) + partial(self.updateSpinBox, self.settingsTab.div0_spinBox, "div0") + ) self.settingsTab.div1_spinBox.valueChanged.connect( - partial(self.updateSpinBox, self.settingsTab.div1_spinBox, "div1")) + partial(self.updateSpinBox, self.settingsTab.div1_spinBox, "div1") + ) self.settingsTab.squashStretchProfile_pushButton.clicked.connect( - self.setProfile) + self.setProfile + ) self.settingsTab.ikTR_checkBox.stateChanged.connect( - partial(self.updateCheck, self.settingsTab.ikTR_checkBox, "ikTR")) + partial(self.updateCheck, self.settingsTab.ikTR_checkBox, "ikTR") + ) self.settingsTab.mirrorMid_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.mirrorMid_checkBox, "mirrorMid")) + partial( + self.updateCheck, + self.settingsTab.mirrorMid_checkBox, + "mirrorMid", + ) + ) self.settingsTab.extraTweak_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.extraTweak_checkBox, "extraTweak")) + partial( + self.updateCheck, + self.settingsTab.extraTweak_checkBox, + "extraTweak", + ) + ) self.settingsTab.TPoseRest_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.TPoseRest_checkBox, "FK_rest_T_Pose")) + partial( + self.updateCheck, + self.settingsTab.TPoseRest_checkBox, + "FK_rest_T_Pose", + ) + ) self.settingsTab.useBlade_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.useBlade_checkBox, "use_blade")) + partial( + self.updateCheck, + self.settingsTab.useBlade_checkBox, + "use_blade", + ) + ) self.settingsTab.mirrorIK_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.mirrorIK_checkBox, - "mirrorIK")) + partial( + self.updateCheck, + self.settingsTab.mirrorIK_checkBox, + "mirrorIK", + ) + ) self.settingsTab.ikRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.upvRefArray_listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.upvRefArray_listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_listWidget.installEventFilter(self) self.settingsTab.upvRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArray_listWidget.installEventFilter(self) self.settingsTab.pinRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArray_listWidget.installEventFilter(self) self.mainSettingsTab.connector_comboBox.currentIndexChanged.connect( - partial(self.updateConnector, - self.mainSettingsTab.connector_comboBox, - self.connector_items)) + partial( + self.updateConnector, + self.mainSettingsTab.connector_comboBox, + self.connector_items, + ) + ) def eventFilter(self, sender, event): if event.type() == QtCore.QEvent.ChildRemoved: diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/__init__.py index c0789e89..51ab3735 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/__init__.py @@ -1,4 +1,3 @@ - import pymel.core as pm from pymel.core import datatypes @@ -27,11 +26,14 @@ def addObjects(self): self.normal = self.getNormalFromPos(self.guide.apos) self.length0 = vector.getDistance( - self.guide.apos[0], self.guide.apos[1]) + self.guide.apos[0], self.guide.apos[1] + ) self.length1 = vector.getDistance( - self.guide.apos[1], self.guide.apos[2]) + self.guide.apos[1], self.guide.apos[2] + ) self.length2 = vector.getDistance( - self.guide.apos[2], self.guide.apos[3]) + self.guide.apos[2], self.guide.apos[3] + ) # 1 bone chain for upv ref self.legChainUpvRef = primitive.add2DChain( @@ -40,32 +42,37 @@ def addObjects(self): [self.guide.apos[0], self.guide.apos[2]], self.normal, False, - self.WIP) + self.WIP, + ) self.legChainUpvRef[1].setAttr( - "jointOrientZ", - self.legChainUpvRef[1].getAttr("jointOrientZ") * -1) + "jointOrientZ", self.legChainUpvRef[1].getAttr("jointOrientZ") * -1 + ) # extra neutral pose t = transform.getTransformFromPos(self.guide.apos[0]) - self.root_npo = primitive.addTransform(self.root, - self.getName("root_npo"), - t) - self.root_ctl = self.addCtl(self.root_npo, - "root_ctl", - t, - self.color_fk, - "circle", - w=self.length0 / 6, - tp=self.parentCtlTag) + self.root_npo = primitive.addTransform( + self.root, self.getName("root_npo"), t + ) + self.root_ctl = self.addCtl( + self.root_npo, + "root_ctl", + t, + self.color_fk, + "circle", + w=self.length0 / 6, + tp=self.parentCtlTag, + ) # FK Controlers ----------------------------------- - t = transform.getTransformLookingAt(self.guide.apos[0], - self.guide.apos[1], - self.normal, - "xz", - self.negate) + t = transform.getTransformLookingAt( + self.guide.apos[0], + self.guide.apos[1], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: if self.negate: x_dir = 1 @@ -83,81 +90,97 @@ def addObjects(self): else: t_npo = t - self.fk0_npo = primitive.addTransform(self.root_ctl, - self.getName("fk0_npo"), - t_npo) - po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0) - self.fk0_ctl = self.addCtl(self.fk0_npo, - "fk0_ctl", - t, - self.color_fk, - "cube", - w=self.length0, - h=self.size * .1, - d=self.size * .1, - po=po_vec, - tp=self.root_ctl) + self.fk0_npo = primitive.addTransform( + self.root_ctl, self.getName("fk0_npo"), t_npo + ) + po_vec = datatypes.Vector(0.5 * self.length0 * self.n_factor, 0, 0) + self.fk0_ctl = self.addCtl( + self.fk0_npo, + "fk0_ctl", + t, + self.color_fk, + "cube", + w=self.length0, + h=self.size * 0.1, + d=self.size * 0.1, + po=po_vec, + tp=self.root_ctl, + ) attribute.setKeyableAttributes( - self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[1], + self.guide.apos[2], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk0_ctl), self.guide.apos[1]) + transform.getTransform(self.fk0_ctl), self.guide.apos[1] + ) else: t_npo = t self.fk1_npo = primitive.addTransform( - self.fk0_ctl, self.getName("fk1_npo"), t_npo) - - po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0) - self.fk1_ctl = self.addCtl(self.fk1_npo, - "fk1_ctl", - t, - self.color_fk, - "cube", - w=self.length1, - h=self.size * .1, - d=self.size * .1, - po=po_vec, - tp=self.fk0_ctl) + self.fk0_ctl, self.getName("fk1_npo"), t_npo + ) + + po_vec = datatypes.Vector(0.5 * self.length1 * self.n_factor, 0, 0) + self.fk1_ctl = self.addCtl( + self.fk1_npo, + "fk1_ctl", + t, + self.color_fk, + "cube", + w=self.length1, + h=self.size * 0.1, + d=self.size * 0.1, + po=po_vec, + tp=self.fk0_ctl, + ) attribute.setKeyableAttributes( - self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]) + 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) + t = transform.getTransformLookingAt( + self.guide.apos[2], + self.guide.apos[3], + self.normal, + "xz", + self.negate, + ) if self.settings["FK_rest_T_Pose"]: t_npo = transform.setMatrixPosition( - transform.getTransform(self.fk0_ctl), self.guide.apos[2]) + transform.getTransform(self.fk0_ctl), self.guide.apos[2] + ) else: t_npo = t self.fk2_npo = primitive.addTransform( - self.fk1_ctl, self.getName("fk2_npo"), t_npo) + self.fk1_ctl, self.getName("fk2_npo"), t_npo + ) if self.settings["FK_rest_T_Pose"]: self.fk2_npo.rz.set(90) - po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0) - self.fk2_ctl = self.addCtl(self.fk2_npo, - "fk2_ctl", - t, - self.color_fk, - "cube", - w=self.length2, - h=self.size * .1, - d=self.size * .1, - po=po_vec, - tp=self.fk1_ctl) + po_vec = datatypes.Vector(0.5 * self.length2 * self.n_factor, 0, 0) + self.fk2_ctl = self.addCtl( + self.fk2_npo, + "fk2_ctl", + t, + self.color_fk, + "cube", + w=self.length2, + h=self.size * 0.1, + d=self.size * 0.1, + po=po_vec, + tp=self.fk1_ctl, + ) attribute.setKeyableAttributes(self.fk2_ctl) self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl] @@ -167,9 +190,9 @@ def addObjects(self): # IK Controlers ----------------------------------- - self.ik_cns = primitive.addTransformFromPos(self.root_ctl, - self.getName("ik_cns"), - self.guide.pos["ankle"]) + self.ik_cns = primitive.addTransformFromPos( + self.root_ctl, self.getName("ik_cns"), self.guide.pos["ankle"] + ) self.ikcns_ctl = self.addCtl( self.ik_cns, @@ -177,8 +200,9 @@ def addObjects(self): transform.getTransformFromPos(self.guide.pos["ankle"]), self.color_ik, "null", - w=self.size * .12, - tp=self.root_ctl) + w=self.size * 0.12, + tp=self.root_ctl, + ) attribute.setInvertMirror(self.ikcns_ctl, ["tx"]) # m = transform.getTransformLookingAt(self.guide.pos["ankle"], @@ -201,9 +225,10 @@ def addObjects(self): t_ik, self.color_ik, "cube", - w=self.size * .12, - h=self.size * .12, - d=self.size * .12) + w=self.size * 0.12, + h=self.size * 0.12, + d=self.size * 0.12, + ) attribute.setKeyableAttributes(self.ik_ctl) attribute.setRotOrder(self.ik_ctl, "XZY") attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"]) @@ -212,12 +237,12 @@ def addObjects(self): v = self.guide.apos[2] - self.guide.apos[0] v = self.normal ^ v v.normalize() - v *= self.size * .5 + v *= self.size * 0.5 v += self.guide.apos[1] - self.upv_cns = primitive.addTransformFromPos(self.ik_ctl, - self.getName("upv_cns"), - v) + self.upv_cns = primitive.addTransformFromPos( + self.ik_ctl, self.getName("upv_cns"), v + ) self.upv_ctl = self.addCtl( self.upv_cns, @@ -225,8 +250,9 @@ def addObjects(self): transform.getTransform(self.upv_cns), self.color_ik, "diamond", - w=self.size * .12, - tp=self.root_ctl) + w=self.size * 0.12, + tp=self.root_ctl, + ) self.add_controller_tag(self.ik_ctl, self.upv_ctl) if self.settings["mirrorMid"]: @@ -241,70 +267,80 @@ def addObjects(self): self.ik_ref = primitive.addTransform( self.ik_ctl, self.getName("ik_ref"), - transform.getTransform(self.ik_ctl)) + transform.getTransform(self.ik_ctl), + ) self.fk_ref = primitive.addTransform( self.fk_ctl[2], self.getName("fk_ref"), - transform.getTransform(self.ik_ctl)) + transform.getTransform(self.ik_ctl), + ) # Chain -------------------------------------------- # The outputs of the ikfk2bone solver self.bone0 = primitive.addLocator( self.root_ctl, self.getName("0_bone"), - transform.getTransform(self.fk_ctl[0])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone0_shp.setAttr("localScale", 0.5, 0, 0) self.bone0.setAttr("sx", self.length0) self.bone0.setAttr("visibility", False) self.bone1 = primitive.addLocator( self.root_ctl, self.getName("1_bone"), - transform.getTransform(self.fk_ctl[1])) + 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_shp.setAttr("localPositionX", self.n_factor * 0.5) + self.bone1_shp.setAttr("localScale", 0.5, 0, 0) self.bone1.setAttr("sx", self.length1) self.bone1.setAttr("visibility", False) - self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl, - self.getName("ctrn_loc"), - self.guide.apos[1]) - self.eff_loc = primitive.addTransformFromPos(self.root_ctl, - self.getName("eff_loc"), - self.guide.apos[2]) + self.ctrn_loc = primitive.addTransformFromPos( + self.root_ctl, self.getName("ctrn_loc"), self.guide.apos[1] + ) + self.eff_loc = primitive.addTransformFromPos( + self.root_ctl, self.getName("eff_loc"), self.guide.apos[2] + ) # tws_ref t = transform.getRotationFromAxis( - datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate) + datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate + ) t = transform.setMatrixPosition(t, self.guide.pos["ankle"]) # addind an npo parent transform to fix flip in Maya 2018.2 self.tws_npo = primitive.addTransform( - self.eff_loc, self.getName("tws_npo"), t) + self.eff_loc, self.getName("tws_npo"), t + ) self.tws_ref = primitive.addTransform( - self.tws_npo, self.getName("tws_ref"), t) + self.tws_npo, self.getName("tws_ref"), t + ) # Mid Controler ------------------------------------ t = transform.getTransform(self.ctrn_loc) self.mid_cns = primitive.addTransform( - self.ctrn_loc, self.getName("mid_cns"), t) - self.mid_ctl = self.addCtl(self.mid_cns, - "mid_ctl", - t, - self.color_ik, - "sphere", - w=self.size * .2, - tp=self.root_ctl) - - attribute.setKeyableAttributes(self.mid_ctl, - params=["tx", "ty", "tz", - "ro", "rx", "ry", "rz", - "sx"]) + self.ctrn_loc, self.getName("mid_cns"), t + ) + self.mid_ctl = self.addCtl( + self.mid_cns, + "mid_ctl", + t, + self.color_ik, + "sphere", + w=self.size * 0.2, + tp=self.root_ctl, + ) + + attribute.setKeyableAttributes( + self.mid_ctl, + params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"], + ) if self.settings["mirrorMid"]: if self.negate: @@ -321,51 +357,58 @@ def addObjects(self): m = transform.getRotationFromAxis(x, z, "xz", self.negate) m = transform.setMatrixPosition( - m, transform.getTranslation(self.ik_ctl)) - - self.rollRef = primitive.add2DChain(self.root, - self.getName("rollChain"), - self.guide.apos[:2], - self.normal, - self.negate, - self.WIP) - - t = transform.getTransformLookingAt(self.guide.pos["base"], - self.guide.apos[1], - self.normal, - "xz", - self.negate) + m, transform.getTranslation(self.ik_ctl) + ) + + self.rollRef = primitive.add2DChain( + self.root, + self.getName("rollChain"), + self.guide.apos[:2], + self.normal, + self.negate, + self.WIP, + ) + + t = transform.getTransformLookingAt( + self.guide.pos["base"], + self.guide.apos[1], + self.normal, + "xz", + self.negate, + ) self.tws0_loc = primitive.addTransform( - self.root_ctl, - self.getName("tws0_loc"), - t) + self.root_ctl, self.getName("tws0_loc"), t + ) self.tws0_rot = primitive.addTransform( - self.tws0_loc, - self.getName("tws0_rot"), - t) + self.tws0_loc, self.getName("tws0_rot"), t + ) self.tws1_loc = primitive.addTransform( self.ctrn_loc, self.getName("tws1_loc"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws1_rot = primitive.addTransform( self.tws1_loc, self.getName("tws1_rot"), - transform.getTransform(self.ctrn_loc)) + transform.getTransform(self.ctrn_loc), + ) self.tws2_loc = primitive.addTransform( self.root_ctl, self.getName("tws2_loc"), - transform.getTransform(self.tws_ref)) + transform.getTransform(self.tws_ref), + ) self.tws2_rot = primitive.addTransform( self.tws2_loc, self.getName("tws2_rot"), - transform.getTransform(self.tws_ref)) + transform.getTransform(self.tws_ref), + ) - self.tws2_rot.setAttr("sx", .001) + self.tws2_rot.setAttr("sx", 0.001) # Divisions ---------------------------------------- @@ -379,22 +422,25 @@ def addObjects(self): for i in range(self.divisions): - div_cns = primitive.addTransform(self.root_ctl, - self.getName("div%s_loc" % i)) + div_cns = primitive.addTransform( + self.root_ctl, self.getName("div%s_loc" % i) + ) self.div_cns.append(div_cns) if self.settings["extraTweak"]: t = transform.getTransform(div_cns) - tweak_ctl = self.addCtl(div_cns, - "tweak%s_ctl" % i, - t, - self.color_fk, - "square", - w=self.size * .15, - d=self.size * .15, - ro=datatypes.Vector([0, 0, 1.5708]), - tp=tagP) + tweak_ctl = self.addCtl( + div_cns, + "tweak%s_ctl" % i, + t, + self.color_fk, + "square", + w=self.size * 0.15, + d=self.size * 0.15, + ro=datatypes.Vector([0, 0, 1.5708]), + tp=tagP, + ) attribute.setKeyableAttributes(tweak_ctl) tagP = tweak_ctl @@ -418,128 +464,149 @@ def addObjects(self): increment = -1 else: self.jnt_pos.append( - [driver, - twist_name + str(twist_idx).zfill(2), - current_parent]) + [ + driver, + twist_name + str(twist_idx).zfill(2), + current_parent, + ] + ) twist_idx += increment # End reference ------------------------------------ # To help the deformation on the ankle - self.end_ref = primitive.addTransform(self.tws2_rot, - self.getName("end_ref"), m) + self.end_ref = primitive.addTransform( + self.tws2_rot, self.getName("end_ref"), m + ) # set the offset rotation for the hand - self.end_jnt_off = primitive.addTransform(self.end_ref, - self.getName("end_off"), m) + self.end_jnt_off = primitive.addTransform( + self.end_ref, self.getName("end_off"), m + ) if self.up_axis == "z": self.end_jnt_off.rz.set(-90) - self.jnt_pos.append([self.end_jnt_off, 'foot', current_parent]) + self.jnt_pos.append([self.end_jnt_off, "foot", current_parent]) # match IK FK references - self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], - self.root, - "matchFk0_npo", - False) + self.match_fk0_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_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_off = self.add_match_ref( + self.fk_ctl[2], self.root, "matchFk1_npo", False + ) - self.match_fk1 = self.add_match_ref(self.fk_ctl[1], - self.match_fk1_off, - "fk1_mth") + self.match_fk1 = self.add_match_ref( + self.fk_ctl[1], self.match_fk1_off, "fk1_mth" + ) - self.match_fk2 = self.add_match_ref(self.fk_ctl[2], - self.ik_ctl, - "fk2_mth") + self.match_fk2 = self.add_match_ref( + self.fk_ctl[2], self.ik_ctl, "fk2_mth" + ) - self.match_ik = self.add_match_ref(self.ik_ctl, - self.fk2_ctl, - "ik_mth") + self.match_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") + 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]) + self.getName("visalRef"), [self.upv_ctl, self.mid_ctl] + ) def addAttributes(self): # Anim ------------------------------------------- self.blend_att = self.addAnimParam( - "blend", "Fk/Ik Blend", "double", self.settings["blend"], 0, 1) + "blend", "Fk/Ik Blend", "double", self.settings["blend"], 0, 1 + ) self.roll_att = self.addAnimParam( - "roll", "Roll", "double", 0, -180, 180) + "roll", "Roll", "double", 0, -180, 180 + ) self.scale_att = self.addAnimParam( - "ikscale", "Scale", "double", 1, .001, 99) - self.maxstretch_att = self.addAnimParam("maxstretch", - "Max Stretch", - "double", - self.settings["maxstretch"], - 1, - 99) + "ikscale", "Scale", "double", 1, 0.001, 99 + ) + self.maxstretch_att = self.addAnimParam( + "maxstretch", + "Max Stretch", + "double", + self.settings["maxstretch"], + 1, + 99, + ) self.slide_att = self.addAnimParam( - "slide", "Slide", "double", .5, 0, 1) + "slide", "Slide", "double", 0.5, 0, 1 + ) self.softness_att = self.addAnimParam( - "softness", "Softness", "double", 0, 0, 1) + "softness", "Softness", "double", 0, 0, 1 + ) self.reverse_att = self.addAnimParam( - "reverse", "Reverse", "double", 0, 0, 1) + "reverse", "Reverse", "double", 0, 0, 1 + ) self.roundness_att = self.addAnimParam( - "roundness", "Roundness", "double", 0, 0, self.size) + "roundness", "Roundness", "double", 0, 0, self.size + ) self.volume_att = self.addAnimParam( - "volume", "Volume", "double", 1, 0, 1) + "volume", "Volume", "double", 1, 0, 1 + ) if self.settings["extraTweak"]: self.tweakVis_att = self.addAnimParam( - "Tweak_vis", "Tweak Vis", "bool", False) + "Tweak_vis", "Tweak Vis", "bool", False + ) # Ref if self.settings["ikrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) if len(ref_names) > 1: self.ikref_att = self.addAnimEnumParam( "ikref", "Ik Ref", 0, - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(","), + ) ref_names = ["Auto", "ikFoot"] if self.settings["upvrefarray"]: ref_names = ref_names + self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) self.upvref_att = self.addAnimEnumParam( - "upvref", "UpV Ref", 0, ref_names) + "upvref", "UpV Ref", 0, ref_names + ) if self.settings["pinrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["pinrefarray"].split(",")) + self.settings["pinrefarray"].split(",") + ) ref_names = ["Auto"] + ref_names if len(ref_names) > 1: - self.pin_att = self.addAnimEnumParam("kneeref", - "Knee Ref", - 0, - ref_names) + self.pin_att = self.addAnimEnumParam( + "kneeref", "Knee Ref", 0, ref_names + ) if self.validProxyChannels: attrs_list = [self.blend_att, self.roundness_att] if self.settings["extraTweak"]: attrs_list += [self.tweakVis_att] attribute.addProxyAttribute( attrs_list, - [self.fk0_ctl, + [ + self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.ik_ctl, self.upv_ctl, - self.mid_ctl]) - attribute.addProxyAttribute(self.roll_att, - [self.ik_ctl, self.upv_ctl]) + self.mid_ctl, + ], + ) + attribute.addProxyAttribute( + self.roll_att, [self.ik_ctl, self.upv_ctl] + ) # Setup ------------------------------------------ # Eval Fcurve @@ -547,25 +614,42 @@ def addAttributes(self): self.st_value = self.guide.paramDefs["st_profile"].value self.sq_value = self.guide.paramDefs["sq_profile"].value else: - self.st_value = fcurve.getFCurveValues(self.settings["st_profile"], - self.divisions) - self.sq_value = fcurve.getFCurveValues(self.settings["sq_profile"], - self.divisions) - - self.st_att = [self.addSetupParam("stretch_%s" % i, - "Stretch %s" % i, - "double", self.st_value[i], -1, 0) - for i in range(self.divisions)] - self.sq_att = [self.addSetupParam("squash_%s" % i, - "Squash %s" % i, - "double", - self.sq_value[i], 0, 1) - for i in range(self.divisions)] + self.st_value = fcurve.getFCurveValues( + self.settings["st_profile"], self.divisions + ) + self.sq_value = fcurve.getFCurveValues( + self.settings["sq_profile"], self.divisions + ) + + self.st_att = [ + self.addSetupParam( + "stretch_%s" % i, + "Stretch %s" % i, + "double", + self.st_value[i], + -1, + 0, + ) + for i in range(self.divisions) + ] + self.sq_att = [ + self.addSetupParam( + "squash_%s" % i, + "Squash %s" % i, + "double", + self.sq_value[i], + 0, + 1, + ) + for i in range(self.divisions) + ] self.resample_att = self.addSetupParam( - "resample", "Resample", "bool", True) + "resample", "Resample", "bool", True + ) self.absolute_att = self.addSetupParam( - "absolute", "Absolute", "bool", False) + "absolute", "Absolute", "bool", False + ) # ===================================================== # OPERATORS @@ -584,12 +668,12 @@ def addOperators(self): self.root, self.getName("ikHandleLegChainUpvRef"), self.legChainUpvRef, - "ikSCsolver") + "ikSCsolver", + ) pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef) - pm.parentConstraint(self.legChainUpvRef[0], - self.ik_ctl, - self.upv_cns, - mo=True) + pm.parentConstraint( + self.legChainUpvRef[0], self.ik_ctl, self.upv_cns, mo=True + ) # Visibilities ------------------------------------- # shape.dispGeometry @@ -617,16 +701,18 @@ def addOperators(self): # IK Solver ----------------------------------------- out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_loc] - o_node = applyop.gear_ikfk2bone_op(out, - self.root_ctl, - self.ik_ref, - self.upv_ctl, - self.fk_ctl[0], - self.fk_ctl[1], - self.fk_ref, - self.length0, - self.length1, - self.negate) + o_node = applyop.gear_ikfk2bone_op( + out, + self.root_ctl, + self.ik_ref, + self.upv_ctl, + self.fk_ctl[0], + self.fk_ctl[1], + self.fk_ref, + self.length0, + self.length1, + self.negate, + ) pm.connectAttr(self.blend_att, o_node + ".blend") if self.negate: @@ -646,7 +732,8 @@ def addOperators(self): self.getName("legRollRef"), self.rollRef, parent=self.root, - cParent=self.bone0) + cParent=self.bone0, + ) pm.pointConstraint(self.mid_ctl, self.tws1_loc, maintainOffset=False) pm.connectAttr(self.mid_ctl.scaleX, self.tws1_loc.scaleX) @@ -665,26 +752,25 @@ def addOperators(self): applyop.oriCns(ori_ref, self.tws0_loc, maintainOffset=True) - self.tws0_loc.setAttr("sx", .001) - self.tws2_loc.setAttr("sx", .001) + self.tws0_loc.setAttr("sx", 0.001) + self.tws2_loc.setAttr("sx", 0.001) - add_node = node.createAddNode(self.roundness_att, .0) + add_node = node.createAddNode(self.roundness_att, 0.0) pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx")) # Volume ------------------------------------------- distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc) distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc) - add_node = node.createAddNode(distA_node.distance, - distB_node.distance) - div_node = node.createDivNode(add_node.output, - self.root_ctl.attr("sx")) + add_node = node.createAddNode(distA_node.distance, distB_node.distance) + div_node = node.createDivNode( + add_node.output, self.root_ctl.attr("sx") + ) # comp scaling issue dm_node = pm.createNode("decomposeMatrix") pm.connectAttr(self.root.attr("worldMatrix"), dm_node.inputMatrix) - div_node2 = node.createDivNode(div_node.outputX, - dm_node.outputScaleX) + div_node2 = node.createDivNode(div_node.outputX, dm_node.outputScaleX) self.volDriver_att = div_node2.outputX @@ -699,15 +785,15 @@ def addOperators(self): for i, div_cns in enumerate(self.div_cns): subdiv = 40 if i < (self.settings["div0"] + 1): - perc = i * .5 / (self.settings["div0"] + 1.0) + perc = i * 0.5 / (self.settings["div0"] + 1.0) elif i < (self.settings["div0"] + 2): - perc = .501 + perc = 0.501 else: - perc = .5 + \ - (i - self.settings["div0"] - 1.0) * .5 / \ - (self.settings["div1"] + 1.0) + perc = 0.5 + (i - self.settings["div0"] - 1.0) * 0.5 / ( + self.settings["div1"] + 1.0 + ) - perc = max(.0001, min(.999, perc)) + perc = max(0.0001, min(0.999, perc)) # Roll if self.negate: @@ -715,20 +801,23 @@ def addOperators(self): div_cns, [self.tws2_rot, self.tws1_rot, self.tws0_rot], 1.0 - perc, - subdiv) + subdiv, + ) else: o_node = applyop.gear_rollsplinekine_op( div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot], perc, - subdiv) + subdiv, + ) pm.connectAttr(self.resample_att, o_node.resample) pm.connectAttr(self.absolute_att, o_node.absolute) # Squash n Stretch o_node = applyop.gear_squashstretch2_op( - div_cns, None, pm.getAttr(self.volDriver_att), "x") + div_cns, None, pm.getAttr(self.volDriver_att), "x" + ) pm.connectAttr(self.volume_att, o_node.blend) pm.connectAttr(self.volDriver_att, o_node.driver) pm.connectAttr(self.st_att[i], o_node.stretch) @@ -767,22 +856,26 @@ def connect_standard(self): # Set the Ik Reference self.connectRef(self.settings["ikrefarray"], self.ik_cns) if self.settings["upvrefarray"]: - self.connectRef("Auto,Foot," + self.settings["upvrefarray"], - self.upv_cns, True) + self.connectRef( + "Auto,Foot," + self.settings["upvrefarray"], self.upv_cns, True + ) else: self.connectRef("Auto,Foot", self.upv_cns, True) if self.settings["pinrefarray"]: - self.connectRef2("Auto," + self.settings["pinrefarray"], - self.mid_cns, - self.pin_att, - [self.ctrn_loc], - False) + self.connectRef2( + "Auto," + self.settings["pinrefarray"], + self.mid_cns, + self.pin_att, + [self.ctrn_loc], + False, + ) def collect_build_data(self): component.Main.collect_build_data(self) - self.build_data['DataContracts'] = ["ik"] - self.build_data['ik'] = [ + self.build_data["DataContracts"] = ["ik"] + self.build_data["ik"] = [ self.jointList[0].name(), self.jointList[self.settings["div0"] + 1].name(), - self.jointList[-1].name()] + self.jointList[-1].name(), + ] diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/guide.py index d68707ed..50bb29a8 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_mannequin_leg_01/guide.py @@ -1,4 +1,3 @@ - from functools import partial from mgear.shifter.component import guide @@ -17,8 +16,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_mannequin_leg_01" NAME = "leg" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on leg_2jnt_01" +) ########################################################## # CLASS @@ -49,7 +50,7 @@ def addObjects(self): self.knee = self.addLoc("knee", self.root, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, -6, 0]) self.ankle = self.addLoc("ankle", self.knee, vTemp) - vTemp = transform.getOffsetPosition(self.root, [0, -6, .5]) + vTemp = transform.getOffsetPosition(self.root, [0, -6, 0.5]) self.eff = self.addLoc("eff", self.ankle, vTemp) vTemp = transform.getOffsetPosition(self.root, [0, 0, 0]) @@ -79,23 +80,27 @@ def addParameters(self): # FCurves self.pSt_profile = self.addFCurveParam( - "st_profile", [[0, 0], [.5, -.5], [1, 0]]) + "st_profile", [[0, 0], [0.5, -0.5], [1, 0]] + ) self.pSq_profile = self.addFCurveParam( - "sq_profile", [[0, 0], [.5, .5], [1, 0]]) + "sq_profile", [[0, 0], [0.5, 0.5], [1, 0]] + ) self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) def get_divisions(self): - """ Returns correct segments divisions """ + """Returns correct segments divisions""" self.divisions = self.root.div0.get() + self.root.div1.get() + 3 return self.divisions + ########################################################## # Setting Page ########################################################## @@ -149,18 +154,22 @@ def populate_componentControls(self): # populate component settings self.settingsTab.ikfk_slider.setValue( - int(self.root.attr("blend").get() * 100)) + int(self.root.attr("blend").get() * 100) + ) self.settingsTab.ikfk_spinBox.setValue( - int(self.root.attr("blend").get() * 100)) + int(self.root.attr("blend").get() * 100) + ) self.settingsTab.maxStretch_spinBox.setValue( - self.root.attr("maxstretch").get()) + self.root.attr("maxstretch").get() + ) self.populateCheck(self.settingsTab.mirrorMid_checkBox, "mirrorMid") self.populateCheck(self.settingsTab.extraTweak_checkBox, "extraTweak") - self.populateCheck(self.settingsTab.TPoseRest_checkBox, - "FK_rest_T_Pose") + self.populateCheck( + self.settingsTab.TPoseRest_checkBox, "FK_rest_T_Pose" + ) self.settingsTab.div0_spinBox.setValue(self.root.attr("div0").get()) self.settingsTab.div1_spinBox.setValue(self.root.attr("div1").get()) ikRefArrayItems = self.root.attr("ikrefarray").get().split(",") @@ -184,88 +193,134 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.ikfk_slider.valueChanged.connect( - partial(self.updateSlider, self.settingsTab.ikfk_slider, "blend")) + partial(self.updateSlider, self.settingsTab.ikfk_slider, "blend") + ) self.settingsTab.ikfk_spinBox.valueChanged.connect( - partial(self.updateSlider, self.settingsTab.ikfk_spinBox, "blend")) + partial(self.updateSlider, self.settingsTab.ikfk_spinBox, "blend") + ) self.settingsTab.maxStretch_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxStretch_spinBox, - "maxstretch")) + partial( + self.updateSpinBox, + self.settingsTab.maxStretch_spinBox, + "maxstretch", + ) + ) self.settingsTab.div0_spinBox.valueChanged.connect( - partial(self.updateSpinBox, self.settingsTab.div0_spinBox, "div0")) + partial(self.updateSpinBox, self.settingsTab.div0_spinBox, "div0") + ) self.settingsTab.div1_spinBox.valueChanged.connect( - partial(self.updateSpinBox, self.settingsTab.div1_spinBox, "div1")) + partial(self.updateSpinBox, self.settingsTab.div1_spinBox, "div1") + ) self.settingsTab.squashStretchProfile_pushButton.clicked.connect( - self.setProfile) + self.setProfile + ) self.settingsTab.mirrorMid_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.mirrorMid_checkBox, - "mirrorMid")) + partial( + self.updateCheck, + self.settingsTab.mirrorMid_checkBox, + "mirrorMid", + ) + ) self.settingsTab.extraTweak_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.extraTweak_checkBox, "extraTweak")) + partial( + self.updateCheck, + self.settingsTab.extraTweak_checkBox, + "extraTweak", + ) + ) self.settingsTab.TPoseRest_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.TPoseRest_checkBox, "FK_rest_T_Pose")) + partial( + self.updateCheck, + self.settingsTab.TPoseRest_checkBox, + "FK_rest_T_Pose", + ) + ) self.settingsTab.ikRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.upvRefArray_listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.upvRefArray_listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_listWidget.installEventFilter(self) self.settingsTab.upvRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.upvRefArray_listWidget, - "upvrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.upvRefArray_listWidget, + "upvrefarray", + ) + ) self.settingsTab.upvRefArray_listWidget.installEventFilter(self) self.settingsTab.pinRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.pinRefArray_listWidget, - "pinrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.pinRefArray_listWidget, + "pinrefarray", + ) + ) self.settingsTab.pinRefArray_listWidget.installEventFilter(self) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/__init__.py index 3b6320f2..03f86e56 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/__init__.py @@ -23,7 +23,8 @@ def addObjects(self): # joint Description Names jd_names = ast.literal_eval( - self.settings["jointNamesDescription_custom"]) + self.settings["jointNamesDescription_custom"] + ) jdn_neck = jd_names[0] jdn_head = jd_names[1] @@ -34,33 +35,37 @@ def addObjects(self): 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.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) + 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 * .5, - tp=self.parentCtlTag) + 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") @@ -71,40 +76,47 @@ def addObjects(self): 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 * .2, - tp=self.ik_ctl) + 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.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 * .2, - tp=self.ik_ctl) - - attribute.setKeyableAttributes(self.tan0_ctl, - self.t_params) + 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 ------------------------------------------- @@ -112,44 +124,54 @@ def addObjects(self): self.root, self.getName("mst_crv"), [self.root, self.tan0_ctl, self.tan1_ctl, self.ik_ctl], - 3) + 3, + ) - self.slv_crv = curve.addCurve(self.root, - self.getName("slv_crv"), - [datatypes.Vector()] * 10, - False, - 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) + 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.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.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) + 3, + ) - self.slv_crv = curve.addCurve(self.root, - self.getName("slv_crv"), - [datatypes.Vector()] * 10, - False, - 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) @@ -168,36 +190,43 @@ def addObjects(self): self.ref_twist = [] # adding 1 for the head - self.divisions = (self.settings["division"] + 1) + self.divisions = self.settings["division"] + 1 parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), - transform.getTransform(self.root)) + transform.getTransform(self.root), + ) - t = transform.getTransformLookingAt(self.guide.pos["root"], - self.guide.pos["neck"], - self.normal, - "yx", - self.negate) + 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.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) + 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)) + scl_npo = primitive.addTransform( + parentctl, + self.getName("%s_scl_npo" % i), + transform.getTransform(parentctl), + ) # Controlers (First and last one are fake) @@ -205,24 +234,28 @@ def addObjects(self): fk_ctl = primitive.addTransform( scl_npo, self.getName("%s_loc" % i), - transform.getTransform(parentctl)) + 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 * .2, - h=self.size * .05, - d=self.size * .2, - tp=self.previousCtlTag) + 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") @@ -245,16 +278,20 @@ def addObjects(self): self.guide.pos["neck"], self.guide.blades["blade"].z * -1, "yx", - self.negate) + self.negate, + ) twister = primitive.addTransform( - parent_twistRef, self.getName("%s_rot_ref" % i), t) + parent_twistRef, self.getName("%s_rot_ref" % i), t + ) ref_twist = primitive.addTransform( - parent_twistRef, self.getName("%s_pos_ref" % i), t) + parent_twistRef, self.getName("%s_pos_ref" % i), t + ) ref_twist.setTranslation( - datatypes.Vector(0.0, 0, 1.0), space="preTransform") + datatypes.Vector(0.0, 0, 1.0), space="preTransform" + ) self.twister.append(twister) self.ref_twist.append(ref_twist) @@ -263,27 +300,34 @@ def addObjects(self): attribute.setInvertMirror(x, ["tx", "rz", "ry"]) # Head --------------------------------------------- - t = transform.getTransformLookingAt(self.guide.pos["head"], - self.guide.pos["eff"], - self.normal, - "yx", - self.negate) + 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 * .5, - h=dist, d=self.size * .5, - po=datatypes.Vector(0, dist * .5, 0), - tp=self.previousCtlTag) + 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"]) @@ -302,50 +346,53 @@ def addAttributes(self): "Max Stretch", "double", self.settings["maxstretch"], - 1) - - self.maxsquash_att = self.addAnimParam("maxsquash", - "MaxSquash", - "double", - self.settings["maxsquash"], - 0, - 1) - - self.softness_att = self.addAnimParam("softness", - "Softness", - "double", - self.settings["softness"], - 0, - 1) + 1, + ) + + self.maxsquash_att = self.addAnimParam( + "maxsquash", + "MaxSquash", + "double", + self.settings["maxsquash"], + 0, + 1, + ) + + self.softness_att = self.addAnimParam( + "softness", "Softness", "double", self.settings["softness"], 0, 1 + ) self.lock_ori_att = self.addAnimParam( - "lock_ori", "Lock Ori", "double", 1, 0, 1) + "lock_ori", "Lock Ori", "double", 1, 0, 1 + ) self.tan0_att = self.addAnimParam("tan0", "Tangent 0", "double", 1, 0) self.tan1_att = self.addAnimParam("tan1", "Tangent 1", "double", 1, 0) # Volume self.volume_att = self.addAnimParam( - "volume", "Volume", "double", 1, 0, 1) + "volume", "Volume", "double", 1, 0, 1 + ) # Ref if self.settings["ikrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["ikrefarray"].split(",")) + self.settings["ikrefarray"].split(",") + ) if len(ref_names) > 1: self.ikref_att = self.addAnimEnumParam( - "ikref", - "Ik Ref", - 0, - ref_names) + "ikref", "Ik Ref", 0, ref_names + ) if self.settings["headrefarray"]: ref_names = self.get_valid_alias_list( - self.settings["headrefarray"].split(",")) + self.settings["headrefarray"].split(",") + ) if len(ref_names) > 1: ref_names.insert(0, "self") self.headref_att = self.addAnimEnumParam( - "headref", "Head Ref", 0, ref_names) + "headref", "Head Ref", 0, ref_names + ) # Setup ------------------------------------------ # Eval Fcurve @@ -353,24 +400,36 @@ def addAttributes(self): self.st_value = self.guide.paramDefs["st_profile"].value self.sq_value = self.guide.paramDefs["sq_profile"].value else: - self.st_value = fcurve.getFCurveValues(self.settings["st_profile"], - self.divisions) - self.sq_value = fcurve.getFCurveValues(self.settings["sq_profile"], - self.divisions) - - self.st_att = [self.addSetupParam("stretch_%s" % i, - "Stretch %s" % i, - "double", - self.st_value[i], -1, 0) - for i in range(self.divisions)] - - self.sq_att = [self.addSetupParam("squash_%s" % i, - "Squash %s" % i, - "double", - self.sq_value[i], - 0, - 1) - for i in range(self.divisions)] + self.st_value = fcurve.getFCurveValues( + self.settings["st_profile"], self.divisions + ) + self.sq_value = fcurve.getFCurveValues( + self.settings["sq_profile"], self.divisions + ) + + self.st_att = [ + self.addSetupParam( + "stretch_%s" % i, + "Stretch %s" % i, + "double", + self.st_value[i], + -1, + 0, + ) + for i in range(self.divisions) + ] + + self.sq_att = [ + self.addSetupParam( + "squash_%s" % i, + "Squash %s" % i, + "double", + self.sq_value[i], + 0, + 1, + ) + for i in range(self.divisions) + ] # ===================================================== # OPERATORS @@ -388,28 +447,35 @@ def addOperators(self): d = vector.getDistance(self.guide.pos["root"], self.guide.pos["neck"]) dist_node = node.createDistNode(self.root, self.ik_ctl) rootWorld_node = node.createDecomposeMatrixNode( - self.root.attr("worldMatrix")) - div_node = node.createDivNode(dist_node + ".distance", - rootWorld_node + ".outputScaleX") + self.root.attr("worldMatrix") + ) + div_node = node.createDivNode( + dist_node + ".distance", rootWorld_node + ".outputScaleX" + ) div_node = node.createDivNode(div_node + ".outputX", d) # tan0 - mul_node = node.createMulNode(self.tan0_att, - self.tan0_loc.getAttr("ty")) - res_node = node.createMulNode(mul_node + ".outputX", - div_node + ".outputX") + mul_node = node.createMulNode( + self.tan0_att, self.tan0_loc.getAttr("ty") + ) + res_node = node.createMulNode( + mul_node + ".outputX", div_node + ".outputX" + ) pm.connectAttr(res_node + ".outputX", self.tan0_loc + ".ty") # tan1 - mul_node = node.createMulNode(self.tan1_att, - self.tan1_loc.getAttr("ty")) - res_node = node.createMulNode(mul_node + ".outputX", - div_node + ".outputX") + mul_node = node.createMulNode( + self.tan1_att, self.tan1_loc.getAttr("ty") + ) + res_node = node.createMulNode( + mul_node + ".outputX", div_node + ".outputX" + ) pm.connectAttr(res_node + ".outputX", self.tan1_loc.attr("ty")) # Curves ------------------------------------------- op = applyop.gear_curveslide2_op( - self.slv_crv, self.mst_crv, 0, 1.5, .5, .5) + self.slv_crv, self.mst_crv, 0, 1.5, 0.5, 0.5 + ) pm.connectAttr(self.maxstretch_att, op + ".maxstretch") pm.connectAttr(self.maxsquash_att, op + ".maxsquash") pm.connectAttr(self.softness_att, op + ".softness") @@ -424,85 +490,97 @@ def addOperators(self): u = i / (self.divisions - 1.0) cns = applyop.pathCns( - self.div_cns[i], self.slv_crv, False, u, True) + self.div_cns[i], self.slv_crv, False, u, True + ) cns.setAttr("frontAxis", 1) # front axis is 'Y' cns.setAttr("upAxis", 2) # front axis is 'Z' # Roll intMatrix = applyop.gear_intmatrix_op( - self.intMRef + ".worldMatrix", self.ik_ctl + ".worldMatrix", u) + self.intMRef + ".worldMatrix", self.ik_ctl + ".worldMatrix", u + ) dm_node = node.createDecomposeMatrixNode(intMatrix + ".output") - pm.connectAttr(dm_node + ".outputRotate", - self.twister[i].attr("rotate")) + pm.connectAttr( + dm_node + ".outputRotate", self.twister[i].attr("rotate") + ) - pm.parentConstraint(self.twister[i], - self.ref_twist[i], - maintainOffset=True) + pm.parentConstraint( + self.twister[i], self.ref_twist[i], maintainOffset=True + ) - pm.connectAttr(self.ref_twist[i] + ".translate", - cns + ".worldUpVector") + pm.connectAttr( + self.ref_twist[i] + ".translate", cns + ".worldUpVector" + ) # Squash n Stretch - op = applyop.gear_squashstretch2_op(self.fk_npo[i], - self.root, - pm.arclen(self.slv_crv), - "y") + op = applyop.gear_squashstretch2_op( + self.fk_npo[i], self.root, pm.arclen(self.slv_crv), "y" + ) pm.connectAttr(self.volume_att, op + ".blend") pm.connectAttr(crv_node + ".arcLength", op + ".driver") pm.connectAttr(self.st_att[i], op + ".stretch") pm.connectAttr(self.sq_att[i], op + ".squash") - op.setAttr("driver_min", .1) + op.setAttr("driver_min", 0.1) # scl compas if i != 0: div_node = node.createDivNode( [1, 1, 1], - [self.fk_npo[i - 1] + ".sx", - self.fk_npo[i - 1] + ".sy", - self.fk_npo[i - 1] + ".sz"]) + [ + self.fk_npo[i - 1] + ".sx", + self.fk_npo[i - 1] + ".sy", + self.fk_npo[i - 1] + ".sz", + ], + ) - pm.connectAttr(div_node + ".output", - self.scl_npo[i] + ".scale") + pm.connectAttr( + div_node + ".output", self.scl_npo[i] + ".scale" + ) # Controlers if i == 0: mulmat_node = applyop.gear_mulmatrix_op( self.div_cns[i].attr("worldMatrix"), - self.root.attr("worldInverseMatrix")) + self.root.attr("worldInverseMatrix"), + ) else: mulmat_node = applyop.gear_mulmatrix_op( self.div_cns[i].attr("worldMatrix"), - self.div_cns[i - 1].attr("worldInverseMatrix")) + self.div_cns[i - 1].attr("worldInverseMatrix"), + ) dm_node = node.createDecomposeMatrixNode(mulmat_node + ".output") - pm.connectAttr(dm_node + ".outputTranslate", - self.fk_npo[i].attr("t")) - pm.connectAttr(dm_node + ".outputRotate", - self.fk_npo[i].attr("r")) + pm.connectAttr( + dm_node + ".outputTranslate", self.fk_npo[i].attr("t") + ) + pm.connectAttr(dm_node + ".outputRotate", self.fk_npo[i].attr("r")) # Orientation Lock if i == self.divisions - 1: dm_node = node.createDecomposeMatrixNode( - self.ik_ctl + ".worldMatrix") + self.ik_ctl + ".worldMatrix" + ) blend_node = node.createBlendNode( [dm_node + ".outputRotate%s" % s for s in "XYZ"], [cns + ".rotate%s" % s for s in "XYZ"], - self.lock_ori_att) + self.lock_ori_att, + ) self.div_cns[i].attr("rotate").disconnect() - pm.connectAttr(blend_node + ".output", - self.div_cns[i] + ".rotate") + pm.connectAttr( + blend_node + ".output", self.div_cns[i] + ".rotate" + ) # Head --------------------------------------------- self.fk_ctl[-1].addChild(self.head_cns) # scale compensation dm_node = node.createDecomposeMatrixNode( - self.scl_npo[0] + ".parentInverseMatrix") + self.scl_npo[0] + ".parentInverseMatrix" + ) - pm.connectAttr(dm_node + ".outputScale", - self.scl_npo[0] + ".scale") + pm.connectAttr(dm_node + ".outputScale", self.scl_npo[0] + ".scale") # ===================================================== # CONNECTOR @@ -556,13 +634,13 @@ def connect_standardWithIkRef(self): ref.append(self.rig.findRelative(ref_name)) ref.append(self.head_cns) - cns_node = pm.parentConstraint(*ref, - skipTranslate="none", - maintainOffset=True) + cns_node = pm.parentConstraint( + *ref, skipTranslate="none", maintainOffset=True + ) - cns_attr = pm.parentConstraint(cns_node, - query=True, - weightAliasList=True) + cns_attr = pm.parentConstraint( + cns_node, query=True, weightAliasList=True + ) self.head_cns.attr("tx").disconnect() self.head_cns.attr("ty").disconnect() self.head_cns.attr("tz").disconnect() diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/guide.py index e76352a4..78e185c8 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_neck_01/guide.py @@ -16,8 +16,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_neck_01" NAME = "neck" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on neck_ik_01" +) ########################################################## # CLASS @@ -57,13 +59,15 @@ def addObjects(self): v0 = vector.linearlyInterpolate( self.root.getTranslation(space="world"), self.neck.getTranslation(space="world"), - .333) + 0.333, + ) self.tan0 = self.addLoc("tan0", self.root, v0) v1 = vector.linearlyInterpolate( self.root.getTranslation(space="world"), self.neck.getTranslation(space="world"), - .666) + 0.666, + ) self.tan1 = self.addLoc("tan1", self.neck, v1) @@ -84,7 +88,7 @@ def addParameters(self): # Default values self.pMaxStretch = self.addParam("maxstretch", "double", 1.5, 1) - self.pMaxSquash = self.addParam("maxsquash", "double", .5, 0, 1) + self.pMaxSquash = self.addParam("maxsquash", "double", 0.5, 0, 1) self.pSoftness = self.addParam("softness", "double", 0, 0, 1) # Options @@ -95,18 +99,21 @@ def addParameters(self): # FCurves self.pSt_profile = self.addFCurveParam( - "st_profile", [[0, 0], [.5, -1], [1, 0]]) + "st_profile", [[0, 0], [0.5, -1], [1, 0]] + ) self.pSq_profile = self.addFCurveParam( - "sq_profile", [[0, 0], [.5, 1], [1, 0]]) + "sq_profile", [[0, 0], [0.5, 1], [1, 0]] + ) self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) def get_divisions(self): - """ Returns correct segments divisions """ + """Returns correct segments divisions""" self.divisions = self.root.division.get() + 1 @@ -117,6 +124,7 @@ def get_divisions(self): # Setting Page ########################################################## + class settingsTab(QtWidgets.QDialog, sui.Ui_Form): """The Component settings UI""" @@ -165,28 +173,34 @@ def populate_componentControls(self): # populate component settings self.settingsTab.softness_slider.setValue( - int(self.root.attr("softness").get() * 100)) + int(self.root.attr("softness").get() * 100) + ) self.settingsTab.softness_spinBox.setValue( - int(self.root.attr("softness").get() * 100)) + int(self.root.attr("softness").get() * 100) + ) self.settingsTab.maxStretch_spinBox.setValue( - self.root.attr("maxstretch").get()) + self.root.attr("maxstretch").get() + ) self.settingsTab.maxSquash_spinBox.setValue( - self.root.attr("maxsquash").get()) + self.root.attr("maxsquash").get() + ) self.settingsTab.division_spinBox.setValue( - self.root.attr("division").get()) + self.root.attr("division").get() + ) - self.populateCheck(self.settingsTab.tangentControls_checkBox, - "tangentControls") + self.populateCheck( + self.settingsTab.tangentControls_checkBox, "tangentControls" + ) - self.populateCheck(self.settingsTab.chickenStyleIK_checkBox, - "chickenStyleIK") + self.populateCheck( + self.settingsTab.chickenStyleIK_checkBox, "chickenStyleIK" + ) - self.populateCheck(self.settingsTab.IKWorldOri_checkBox, - "IKWorldOri") + self.populateCheck(self.settingsTab.IKWorldOri_checkBox, "IKWorldOri") ikRefArrayItems = self.root.attr("ikrefarray").get().split(",") for item in ikRefArrayItems: @@ -206,81 +220,122 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.softness_slider.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.softness_slider, - "softness")) + partial( + self.updateSlider, self.settingsTab.softness_slider, "softness" + ) + ) self.settingsTab.softness_spinBox.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.softness_spinBox, - "softness")) + partial( + self.updateSlider, + self.settingsTab.softness_spinBox, + "softness", + ) + ) self.settingsTab.maxStretch_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxStretch_spinBox, - "maxstretch")) + partial( + self.updateSpinBox, + self.settingsTab.maxStretch_spinBox, + "maxstretch", + ) + ) self.settingsTab.maxSquash_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxSquash_spinBox, - "maxsquash")) + partial( + self.updateSpinBox, + self.settingsTab.maxSquash_spinBox, + "maxsquash", + ) + ) self.settingsTab.division_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.division_spinBox, - "division")) + partial( + self.updateSpinBox, + self.settingsTab.division_spinBox, + "division", + ) + ) self.settingsTab.tangentControls_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.tangentControls_checkBox, - "tangentControls")) + partial( + self.updateCheck, + self.settingsTab.tangentControls_checkBox, + "tangentControls", + ) + ) self.settingsTab.chickenStyleIK_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.chickenStyleIK_checkBox, - "chickenStyleIK")) + partial( + self.updateCheck, + self.settingsTab.chickenStyleIK_checkBox, + "chickenStyleIK", + ) + ) self.settingsTab.IKWorldOri_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.IKWorldOri_checkBox, - "IKWorldOri")) + partial( + self.updateCheck, + self.settingsTab.IKWorldOri_checkBox, + "IKWorldOri", + ) + ) self.settingsTab.squashStretchProfile_pushButton.clicked.connect( - self.setProfile) + self.setProfile + ) self.settingsTab.ikRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.headRefArray_listWidget, - self.settingsTab.ikRefArray_listWidget, - "ikrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.headRefArray_listWidget, + self.settingsTab.ikRefArray_listWidget, + "ikrefarray", + ) + ) self.settingsTab.ikRefArray_listWidget.installEventFilter(self) self.settingsTab.headRefArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.headRefArray_listWidget, - "headrefarray")) + partial( + self.addItem2listWidget, + self.settingsTab.headRefArray_listWidget, + "headrefarray", + ) + ) self.settingsTab.headRefArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.headRefArray_listWidget, - "headrefarray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.headRefArray_listWidget, + "headrefarray", + ) + ) self.settingsTab.headRefArray_copyRef_pushButton.clicked.connect( - partial(self.copyFromListWidget, - self.settingsTab.ikRefArray_listWidget, - self.settingsTab.headRefArray_listWidget, - "headrefarray")) + partial( + self.copyFromListWidget, + self.settingsTab.ikRefArray_listWidget, + self.settingsTab.headRefArray_listWidget, + "headrefarray", + ) + ) self.settingsTab.headRefArray_listWidget.installEventFilter(self) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/__init__.py index d49e48f5..ac61335a 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/__init__.py @@ -21,17 +21,21 @@ def addObjects(self): 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.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.root, self.getName("ctl_npo"), t + ) self.ctl = self.addCtl( self.ctl_npo, @@ -40,29 +44,36 @@ def addObjects(self): 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) + h=self.size * 0.1, + d=self.size * 0.1, + po=datatypes.Vector(0.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.ctl, self.getName("orbit_ref1"), t + ) self.orbit_ref2 = primitive.addTransform( - self.root, self.getName("orbit_ref2"), t) + self.root, self.getName("orbit_ref2"), t + ) self.orbit_cns = primitive.addTransform( - self.ctl, self.getName("orbit_cns"), t) + self.ctl, self.getName("orbit_cns"), t + ) self.orbit_npo = primitive.addTransform( - self.orbit_cns, self.getName("orbit_npo"), t) + 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.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, self.name]) @@ -75,10 +86,12 @@ def addAttributes(self): # Ref if self.settings["refArray"]: ref_names = self.get_valid_alias_list( - self.settings["refArray"].split(",")) + self.settings["refArray"].split(",") + ) if len(ref_names) >= 1: self.ref_att = self.addAnimEnumParam( - "rotRef", "Ref", 0, ref_names) + "rotRef", "Ref", 0, ref_names + ) # ===================================================== # OPERATORS @@ -112,5 +125,6 @@ def setRelation(self): def connect_standard(self): self.parent.addChild(self.root) - self.connect_standardWithRotRef(self.settings["refArray"], - self.orbit_cns) + self.connect_standardWithRotRef( + self.settings["refArray"], self.orbit_cns + ) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/guide.py index ddd908e4..f3bb7d3c 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_shoulder_01/guide.py @@ -1,4 +1,3 @@ - from functools import partial from mgear.shifter.component import guide @@ -17,8 +16,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_shoulder_01" NAME = "shoulder" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on shoulder_01, Joint name taken from component instance name" +) ########################################################## # CLASS @@ -60,13 +61,15 @@ def addParameters(self): self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) ########################################################## # Setting Page ########################################################## + class settingsTab(QtWidgets.QDialog, sui.Ui_Form): """The Component settings UI""" @@ -129,14 +132,20 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.refArrayAdd_pushButton.clicked.connect( - partial(self.addItem2listWidget, - self.settingsTab.refArray_listWidget, - "refArray")) + partial( + self.addItem2listWidget, + self.settingsTab.refArray_listWidget, + "refArray", + ) + ) self.settingsTab.refArrayRemove_pushButton.clicked.connect( - partial(self.removeSelectedFromListWidget, - self.settingsTab.refArray_listWidget, - "refArray")) + partial( + self.removeSelectedFromListWidget, + self.settingsTab.refArray_listWidget, + "refArray", + ) + ) self.settingsTab.refArray_listWidget.installEventFilter(self) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/__init__.py b/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/__init__.py index 61892a0f..6c2b95c1 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/__init__.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/__init__.py @@ -30,7 +30,8 @@ def addObjects(self): [self.guide.apos[0], self.guide.apos[-1]], self.guide.blades["blade"].z * -1, False, - True) + True, + ) for j in self.autoBendChain: j.drawStyle.set(2) @@ -45,18 +46,19 @@ def addObjects(self): self.guide.apos[-1], self.guide.blades["blade"].z * -1, "yx", - self.negate) + self.negate, + ) self.ik_off = primitive.addTransform( - self.root, - self.getName("ik_off"), - t) + 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.ik_off, self.getName("ik0_npo"), t + ) self.ik0_ctl = self.addCtl( self.ik0_npo, @@ -65,7 +67,7 @@ def addObjects(self): self.color_ik, "compas", w=self.size, - tp=self.parentCtlTag + tp=self.parentCtlTag, ) attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params) @@ -76,13 +78,15 @@ def addObjects(self): # TODO: add option in setting for on/off if True: self.hip_lvl = primitive.addTransform( - self.ik0_ctl, self.getName("hip_lvl"), t) + self.ik0_ctl, self.getName("hip_lvl"), t + ) self.jnt_pos.append([self.hip_lvl, "pelvis"]) 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.root, self.getName("spinePosition_npo"), t + ) self.autoBend_ctl = self.addCtl( self.autoBend_npo, @@ -91,20 +95,23 @@ def addObjects(self): self.color_ik, "square", w=self.size, - d=.3 * self.size, - tp=self.parentCtlTag + d=0.3 * self.size, + tp=self.parentCtlTag, ) - attribute.setKeyableAttributes(self.autoBend_ctl, - ["tx", "ty", "tz", "ry"]) + 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.autoBendChain[0], self.getName("ik1_npo"), t + ) self.ik1autoRot_lvl = primitive.addTransform( - self.ik1_npo, self.getName("ik1autoRot_lvl"), t) + self.ik1_npo, self.getName("ik1autoRot_lvl"), t + ) self.ik1_ctl = self.addCtl( self.ik1autoRot_lvl, @@ -113,12 +120,13 @@ def addObjects(self): self.color_ik, "compas", w=self.size, - tp=self.autoBend_ctl + 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.root, self.getName("ik1_npo"), t + ) self.ik1_ctl = self.addCtl( self.ik1_npo, @@ -127,7 +135,7 @@ def addObjects(self): self.color_ik, "compas", w=self.size, - tp=self.ik0_ctl + tp=self.ik0_ctl, ) attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params) @@ -143,10 +151,12 @@ def addObjects(self): t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform( - self.ik0_ctl, self.getName("tan0_npo"), t) + self.ik0_ctl, self.getName("tan0_npo"), t + ) self.tan0_off = primitive.addTransform( - self.tan0_npo, self.getName("tan0_off"), t) + self.tan0_npo, self.getName("tan0_off"), t + ) self.tan0_ctl = self.addCtl( self.tan0_off, @@ -154,8 +164,8 @@ def addObjects(self): t, self.color_ik, "sphere", - w=self.size * .1, - tp=self.ik0_ctl + w=self.size * 0.1, + tp=self.ik0_ctl, ) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) @@ -166,10 +176,12 @@ def addObjects(self): t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform( - self.ik1_ctl, self.getName("tan1_npo"), t) + self.ik1_ctl, self.getName("tan1_npo"), t + ) self.tan1_off = primitive.addTransform( - self.tan1_npo, self.getName("tan1_off"), t) + self.tan1_npo, self.getName("tan1_off"), t + ) self.tan1_ctl = self.addCtl( self.tan1_off, @@ -177,20 +189,21 @@ def addObjects(self): t, self.color_ik, "sphere", - w=self.size * .1, - tp=self.ik0_ctl + w=self.size * 0.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) + vec_pos = vector.linearlyInterpolate( + self.guide.apos[0], self.guide.apos[-1], 0.5 + ) t = transform.setMatrixPosition(t, vec_pos) self.tan_npo = primitive.addTransform( - self.tan0_npo, self.getName("tan_npo"), t) + self.tan0_npo, self.getName("tan_npo"), t + ) self.tan_ctl = self.addCtl( self.tan_npo, @@ -198,8 +211,8 @@ def addObjects(self): t, self.color_fk, "sphere", - w=self.size * .2, - tp=self.ik1_ctl + w=self.size * 0.2, + tp=self.ik1_ctl, ) attribute.setKeyableAttributes(self.tan_ctl, self.t_params) @@ -213,7 +226,8 @@ def addObjects(self): t = transform.setMatrixPosition(t, vec_pos) self.tan0_npo = primitive.addTransform( - self.ik0_ctl, self.getName("tan0_npo"), t) + self.ik0_ctl, self.getName("tan0_npo"), t + ) self.tan0_ctl = self.addCtl( self.tan0_npo, @@ -221,8 +235,8 @@ def addObjects(self): t, self.color_ik, "sphere", - w=self.size * .2, - tp=self.ik0_ctl + w=self.size * 0.2, + tp=self.ik0_ctl, ) attribute.setKeyableAttributes(self.tan0_ctl, self.t_params) @@ -234,7 +248,8 @@ def addObjects(self): t = transform.setMatrixPosition(t, vec_pos) self.tan1_npo = primitive.addTransform( - self.ik1_ctl, self.getName("tan1_npo"), t) + self.ik1_ctl, self.getName("tan1_npo"), t + ) self.tan1_ctl = self.addCtl( self.tan1_npo, @@ -242,8 +257,8 @@ def addObjects(self): t, self.color_ik, "sphere", - w=self.size * .2, - tp=self.ik1_ctl + w=self.size * 0.2, + tp=self.ik1_ctl, ) attribute.setKeyableAttributes(self.tan1_ctl, self.t_params) @@ -256,12 +271,14 @@ def addObjects(self): self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], - 3) + 3, + ) self.slv_crv = curve.addCurve( - self.root, self.getName("slv_crv"), + self.root, + self.getName("slv_crv"), [datatypes.Vector()] * 10, False, - 3 + 3, ) self.mst_crv.setAttr("visibility", False) self.slv_crv.setAttr("visibility", False) @@ -283,12 +300,14 @@ def addObjects(self): self.guide.apos[-1], self.guide.blades["blade"].z * -1, "yx", - self.negate) + self.negate, + ) parent_twistRef = primitive.addTransform( self.root, self.getName("reference"), - transform.getTransform(self.root)) + transform.getTransform(self.root), + ) self.jointList = [] self.preiviousCtlTag = self.parentCtlTag @@ -303,8 +322,9 @@ def addObjects(self): for i in range(self.settings["division"]): # References - div_cns = primitive.addTransform(parentdiv, - self.getName("%s_cns" % i)) + 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 @@ -318,7 +338,8 @@ def addObjects(self): fk_ctl = primitive.addTransform( parentctl, self.getName("%s_loc" % i), - transform.getTransform(parentctl)) + transform.getTransform(parentctl), + ) fk_npo = fk_ctl if i in [self.settings["division"] - 1]: @@ -329,9 +350,8 @@ def addObjects(self): m.inverse() fk_npo = primitive.addTransform( - parentctl, - self.getName("fk%s_npo" % (i)), - t) + parentctl, self.getName("fk%s_npo" % (i)), t + ) fk_ctl = self.addCtl( fk_npo, @@ -340,9 +360,10 @@ def addObjects(self): self.color_fk, "cube", w=self.size, - h=self.size * .05, + h=self.size * 0.05, d=self.size, - tp=self.preiviousCtlTag) + tp=self.preiviousCtlTag, + ) attribute.setKeyableAttributes(self.fk_ctl) attribute.setRotOrder(fk_ctl, "ZXY") @@ -354,7 +375,8 @@ def addObjects(self): scl_ref = primitive.addTransform( parentctl, self.getName("%s_scl_ref" % i), - transform.getTransform(parentctl)) + transform.getTransform(parentctl), + ) self.scl_transforms.append(scl_ref) @@ -369,16 +391,20 @@ def addObjects(self): self.guide.apos[-1], self.guide.blades["blade"].z * -1, "yx", - self.negate) + self.negate, + ) twister = primitive.addTransform( - parent_twistRef, self.getName("%s_rot_ref" % i), t) + parent_twistRef, self.getName("%s_rot_ref" % i), t + ) ref_twist = primitive.addTransform( - parent_twistRef, self.getName("%s_pos_ref" % i), t) + parent_twistRef, self.getName("%s_pos_ref" % i), t + ) ref_twist.setTranslation( - datatypes.Vector(1.0, 0, 0), space="preTransform") + datatypes.Vector(1.0, 0, 0), space="preTransform" + ) self.twister.append(twister) self.ref_twist.append(ref_twist) @@ -395,51 +421,64 @@ def addAttributes(self): # Anim ------------------------------------------- self.position_att = self.addAnimParam( - "position", "Position", "double", self.settings["position"], 0, 1) + "position", "Position", "double", self.settings["position"], 0, 1 + ) - self.maxstretch_att = self.addAnimParam("maxstretch", - "Max Stretch", - "double", - self.settings["maxstretch"], - 1) + self.maxstretch_att = self.addAnimParam( + "maxstretch", + "Max Stretch", + "double", + self.settings["maxstretch"], + 1, + ) - self.maxsquash_att = self.addAnimParam("maxsquash", - "Max Squash", - "double", - self.settings["maxsquash"], - 0, - 1) + self.maxsquash_att = self.addAnimParam( + "maxsquash", + "Max Squash", + "double", + self.settings["maxsquash"], + 0, + 1, + ) self.softness_att = self.addAnimParam( - "softness", "Softness", "double", self.settings["softness"], 0, 1) - - self.lock_ori0_att = self.addAnimParam("lock_ori0", - "Lock Ori 0", - "double", - self.settings["lock_ori"], - 0, - 1) - - self.lock_ori1_att = self.addAnimParam("lock_ori1", - "Lock Ori 1", - "double", - self.settings["lock_ori"], - 0, - 1) + "softness", "Softness", "double", self.settings["softness"], 0, 1 + ) + + self.lock_ori0_att = self.addAnimParam( + "lock_ori0", + "Lock Ori 0", + "double", + self.settings["lock_ori"], + 0, + 1, + ) + + self.lock_ori1_att = self.addAnimParam( + "lock_ori1", + "Lock Ori 1", + "double", + self.settings["lock_ori"], + 0, + 1, + ) self.tan0_att = self.addAnimParam("tan0", "Tangent 0", "double", 1, 0) self.tan1_att = self.addAnimParam("tan1", "Tangent 1", "double", 1, 0) # Volume self.volume_att = self.addAnimParam( - "volume", "Volume", "double", 1, 0, 1) + "volume", "Volume", "double", 1, 0, 1 + ) if self.settings["autoBend"]: self.sideBend_att = self.addAnimParam( - "sideBend", "Side Bend", "double", .5, 0, 2) + "sideBend", "Side Bend", "double", 0.5, 0, 2 + ) self.frontBend_att = self.addAnimParam( - "frontBend", "Front Bend", "double", .5, 0, 2) + "frontBend", "Front Bend", "double", 0.5, 0, 2 + ) # Setup ------------------------------------------ # Eval Fcurve @@ -447,26 +486,36 @@ def addAttributes(self): self.st_value = self.guide.paramDefs["st_profile"].value self.sq_value = self.guide.paramDefs["sq_profile"].value else: - self.st_value = fcurve.getFCurveValues(self.settings["st_profile"], - self.divisions) - self.sq_value = fcurve.getFCurveValues(self.settings["sq_profile"], - self.divisions) - - self.st_att = [self.addSetupParam("stretch_%s" % i, - "Stretch %s" % i, - "double", - self.st_value[i], - -1, - 0) - for i in range(self.settings["division"])] - - self.sq_att = [self.addSetupParam("squash_%s" % i, - "Squash %s" % i, - "double", - self.sq_value[i], - 0, - 1) - for i in range(self.settings["division"])] + self.st_value = fcurve.getFCurveValues( + self.settings["st_profile"], self.divisions + ) + self.sq_value = fcurve.getFCurveValues( + self.settings["sq_profile"], self.divisions + ) + + self.st_att = [ + self.addSetupParam( + "stretch_%s" % i, + "Stretch %s" % i, + "double", + self.st_value[i], + -1, + 0, + ) + for i in range(self.settings["division"]) + ] + + self.sq_att = [ + self.addSetupParam( + "squash_%s" % i, + "Squash %s" % i, + "double", + self.sq_value[i], + 0, + 1, + ) + for i in range(self.settings["division"]) + ] # ===================================================== # OPERATORS @@ -484,7 +533,8 @@ def addOperators(self): if self.settings["autoBend"]: mul_node = node.createMulNode( [self.autoBendChain[0].ry, self.autoBendChain[0].rz], - [self.sideBend_att, self.frontBend_att]) + [self.sideBend_att, self.frontBend_att], + ) mul_node.outputX >> self.ik1autoRot_lvl.rz mul_node.outputY >> self.ik1autoRot_lvl.rx @@ -493,35 +543,42 @@ def addOperators(self): self.autoBend_ctl, self.getName("ikHandleAutoBend"), self.autoBendChain, - "ikSCsolver") + "ikSCsolver", + ) # Tangent position --------------------------------- # common part d = vector.getDistance(self.guide.apos[0], self.guide.apos[-1]) dist_node = node.createDistNode(self.ik0_ctl, self.ik1_ctl) rootWorld_node = node.createDecomposeMatrixNode( - self.root.attr("worldMatrix")) + self.root.attr("worldMatrix") + ) - div_node = node.createDivNode(dist_node + ".distance", - rootWorld_node + ".outputScaleX") + div_node = node.createDivNode( + dist_node + ".distance", rootWorld_node + ".outputScaleX" + ) div_node = node.createDivNode(div_node + ".outputX", d) # tan0 - mul_node = node.createMulNode(self.tan0_att, - self.tan0_npo.getAttr("ty")) + mul_node = node.createMulNode( + self.tan0_att, self.tan0_npo.getAttr("ty") + ) - res_node = node.createMulNode(mul_node + ".outputX", - div_node + ".outputX") + res_node = node.createMulNode( + mul_node + ".outputX", div_node + ".outputX" + ) pm.connectAttr(res_node + ".outputX", self.tan0_npo.attr("ty")) # tan1 - mul_node = node.createMulNode(self.tan1_att, - self.tan1_npo.getAttr("ty")) + mul_node = node.createMulNode( + self.tan1_att, self.tan1_npo.getAttr("ty") + ) - res_node = node.createMulNode(mul_node + ".outputX", - div_node + ".outputX") + res_node = node.createMulNode( + mul_node + ".outputX", div_node + ".outputX" + ) pm.connectAttr(res_node + ".outputX", self.tan1_npo.attr("ty")) @@ -530,22 +587,27 @@ def addOperators(self): tanIntMat = applyop.gear_intmatrix_op( self.tan0_npo.attr("worldMatrix"), self.tan1_npo.attr("worldMatrix"), - .5) + 0.5, + ) applyop.gear_mulmatrix_op( tanIntMat.attr("output"), self.tan_npo.attr("parentInverseMatrix[0]"), - self.tan_npo) + self.tan_npo, + ) - pm.connectAttr(self.tan_ctl.attr("translate"), - self.tan0_off.attr("translate")) + pm.connectAttr( + self.tan_ctl.attr("translate"), self.tan0_off.attr("translate") + ) - pm.connectAttr(self.tan_ctl.attr("translate"), - self.tan1_off.attr("translate")) + pm.connectAttr( + self.tan_ctl.attr("translate"), self.tan1_off.attr("translate") + ) # Curves ------------------------------------------- op = applyop.gear_curveslide2_op( - self.slv_crv, self.mst_crv, 0, 1.5, .5, .5) + self.slv_crv, self.mst_crv, 0, 1.5, 0.5, 0.5 + ) pm.connectAttr(self.position_att, op + ".position") pm.connectAttr(self.maxstretch_att, op + ".maxstretch") @@ -564,40 +626,48 @@ def addOperators(self): u = (1.0 / (self.settings["division"] - 1.0)) / 10 cns = applyop.pathCns( - self.div_cns[i], self.slv_crv, False, u, True) + self.div_cns[i], self.slv_crv, False, u, True + ) cns.setAttr("frontAxis", 1) # front axis is 'Y' cns.setAttr("upAxis", 0) # front axis is 'X' # Roll intMatrix = applyop.gear_intmatrix_op( - self.ik0_ctl + ".worldMatrix", - self.ik1_ctl + ".worldMatrix", - u) + self.ik0_ctl + ".worldMatrix", self.ik1_ctl + ".worldMatrix", u + ) dm_node = node.createDecomposeMatrixNode(intMatrix + ".output") - pm.connectAttr(dm_node + ".outputRotate", - self.twister[i].attr("rotate")) + pm.connectAttr( + dm_node + ".outputRotate", self.twister[i].attr("rotate") + ) - pm.parentConstraint(self.twister[i], - self.ref_twist[i], - maintainOffset=True) + pm.parentConstraint( + self.twister[i], self.ref_twist[i], maintainOffset=True + ) - pm.connectAttr(self.ref_twist[i] + ".translate", - cns + ".worldUpVector") + pm.connectAttr( + self.ref_twist[i] + ".translate", cns + ".worldUpVector" + ) # compensate scale reference - div_node = node.createDivNode([1, 1, 1], - [rootWorld_node + ".outputScaleX", - rootWorld_node + ".outputScaleY", - rootWorld_node + ".outputScaleZ"]) + div_node = node.createDivNode( + [1, 1, 1], + [ + rootWorld_node + ".outputScaleX", + rootWorld_node + ".outputScaleY", + rootWorld_node + ".outputScaleZ", + ], + ) # Squash n Stretch - op = applyop.gear_squashstretch2_op(self.scl_transforms[i], - self.root, - pm.arclen(self.slv_crv), - "y", - div_node + ".output") + op = applyop.gear_squashstretch2_op( + self.scl_transforms[i], + self.root, + pm.arclen(self.slv_crv), + "y", + div_node + ".output", + ) pm.connectAttr(self.volume_att, op + ".blend") pm.connectAttr(crv_node + ".arcLength", op + ".driver") @@ -608,24 +678,30 @@ def addOperators(self): if i == 0: mulmat_node = applyop.gear_mulmatrix_op( self.div_cns[i].attr("worldMatrix"), - self.root.attr("worldInverseMatrix")) + self.root.attr("worldInverseMatrix"), + ) dm_node = node.createDecomposeMatrixNode( - mulmat_node + ".output") + mulmat_node + ".output" + ) - pm.connectAttr(dm_node + ".outputTranslate", - self.fk_npo[i].attr("t")) + pm.connectAttr( + dm_node + ".outputTranslate", self.fk_npo[i].attr("t") + ) else: mulmat_node = applyop.gear_mulmatrix_op( self.div_cns[i].attr("worldMatrix"), - self.div_cns[i - 1].attr("worldInverseMatrix")) + self.div_cns[i - 1].attr("worldInverseMatrix"), + ) dm_node = node.createDecomposeMatrixNode( - mulmat_node + ".output") + mulmat_node + ".output" + ) - mul_node = node.createMulNode(div_node + ".output", - dm_node + ".outputTranslate") + mul_node = node.createMulNode( + div_node + ".output", dm_node + ".outputTranslate" + ) pm.connectAttr(mul_node + ".output", self.fk_npo[i].attr("t")) @@ -634,30 +710,36 @@ def addOperators(self): # Orientation Lock if i == 0: dm_node = node.createDecomposeMatrixNode( - self.ik0_ctl + ".worldMatrix") + self.ik0_ctl + ".worldMatrix" + ) blend_node = node.createBlendNode( [dm_node + ".outputRotate%s" % s for s in "XYZ"], [cns + ".rotate%s" % s for s in "XYZ"], - self.lock_ori0_att) + self.lock_ori0_att, + ) self.div_cns[i].attr("rotate").disconnect() - pm.connectAttr(blend_node + ".output", - self.div_cns[i] + ".rotate") + pm.connectAttr( + blend_node + ".output", self.div_cns[i] + ".rotate" + ) elif i == self.settings["division"] - 1: dm_node = node.createDecomposeMatrixNode( - self.ik1_ctl + ".worldMatrix") + self.ik1_ctl + ".worldMatrix" + ) blend_node = node.createBlendNode( [dm_node + ".outputRotate%s" % s for s in "XYZ"], [cns + ".rotate%s" % s for s in "XYZ"], - self.lock_ori1_att) + self.lock_ori1_att, + ) self.div_cns[i].attr("rotate").disconnect() - pm.connectAttr(blend_node + ".output", - self.div_cns[i] + ".rotate") + pm.connectAttr( + blend_node + ".output", self.div_cns[i] + ".rotate" + ) # Connections (Hooks) ------------------------------ pm.parentConstraint(self.hip_lvl, self.cnx0) diff --git a/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/guide.py b/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/guide.py index 1076be89..de143f93 100644 --- a/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/guide.py +++ b/release/scripts/mgear/shifter_epic_components/EPIC_spine_cartoon_01/guide.py @@ -16,8 +16,10 @@ VERSION = [1, 0, 0] TYPE = "EPIC_spine_cartoon_01" NAME = "spine" -DESCRIPTION = "Game ready component for EPIC's UE and other Game Engines\n"\ +DESCRIPTION = ( + "Game ready component for EPIC's UE and other Game Engines\n" "Based on spine_S_shape_01" +) ########################################################## # CLASS @@ -51,14 +53,14 @@ def addObjects(self): vTan0 = vector.linearlyInterpolate( self.root.getTranslation(space="world"), self.eff.getTranslation(space="world"), - 0.3333 + 0.3333, ) self.tan0 = self.addLoc("tan0", self.root, vTan0) vTan1 = vector.linearlyInterpolate( self.eff.getTranslation(space="world"), self.root.getTranslation(space="world"), - 0.3333 + 0.3333, ) self.tan1 = self.addLoc("tan1", self.root, vTan1) @@ -70,9 +72,9 @@ def addObjects(self): # tangent handles self.disp_tancrv0 = self.addDispCurve( - "crvTan0", [self.root, self.tan0]) - self.disp_tancrv1 = self.addDispCurve( - "crvTan1", [self.eff, self.tan1]) + "crvTan0", [self.root, self.tan0] + ) + self.disp_tancrv1 = self.addDispCurve("crvTan1", [self.eff, self.tan1]) def addParameters(self): """Add the configurations settings""" @@ -80,7 +82,7 @@ def addParameters(self): # Default values self.pPosition = self.addParam("position", "double", 0, 0, 1) self.pMaxStretch = self.addParam("maxstretch", "double", 1.5, 1) - self.pMaxSquash = self.addParam("maxsquash", "double", .5, 0, 1) + self.pMaxSquash = self.addParam("maxsquash", "double", 0.5, 0, 1) self.pSoftness = self.addParam("softness", "double", 0, 0, 1) self.pLockOri = self.addParam("lock_ori", "double", 1, 0, 1) @@ -92,18 +94,21 @@ def addParameters(self): # FCurves self.pSt_profile = self.addFCurveParam( - "st_profile", [[0, 0], [.5, -1], [1, 0]]) + "st_profile", [[0, 0], [0.5, -1], [1, 0]] + ) self.pSq_profile = self.addFCurveParam( - "sq_profile", [[0, 0], [.5, 1], [1, 0]]) + "sq_profile", [[0, 0], [0.5, 1], [1, 0]] + ) self.pUseIndex = self.addParam("useIndex", "bool", False) self.pParentJointIndex = self.addParam( - "parentJointIndex", "long", -1, None, None) + "parentJointIndex", "long", -1, None, None + ) def get_divisions(self): - """ Returns correct segments divisions """ + """Returns correct segments divisions""" self.divisions = self.root.division.get() @@ -114,6 +119,7 @@ def get_divisions(self): # Setting Page ########################################################## + class settingsTab(QtWidgets.QDialog, sui.Ui_Form): """The Component settings UI""" @@ -162,27 +168,37 @@ def populate_componentControls(self): # populate component settings self.settingsTab.softness_slider.setValue( - int(self.root.attr("softness").get() * 100)) + int(self.root.attr("softness").get() * 100) + ) self.settingsTab.position_spinBox.setValue( - int(self.root.attr("position").get() * 100)) + int(self.root.attr("position").get() * 100) + ) self.settingsTab.position_slider.setValue( - int(self.root.attr("position").get() * 100)) + int(self.root.attr("position").get() * 100) + ) self.settingsTab.lockOri_spinBox.setValue( - int(self.root.attr("lock_ori").get() * 100)) + int(self.root.attr("lock_ori").get() * 100) + ) self.settingsTab.lockOri_slider.setValue( - int(self.root.attr("lock_ori").get() * 100)) + int(self.root.attr("lock_ori").get() * 100) + ) self.settingsTab.softness_spinBox.setValue( - int(self.root.attr("softness").get() * 100)) + int(self.root.attr("softness").get() * 100) + ) self.settingsTab.maxStretch_spinBox.setValue( - self.root.attr("maxstretch").get()) + self.root.attr("maxstretch").get() + ) self.settingsTab.maxSquash_spinBox.setValue( - self.root.attr("maxsquash").get()) + self.root.attr("maxsquash").get() + ) self.settingsTab.division_spinBox.setValue( - self.root.attr("division").get()) + self.root.attr("division").get() + ) self.populateCheck(self.settingsTab.autoBend_checkBox, "autoBend") self.populateCheck(self.settingsTab.IKWorldOri_checkBox, "IKWorldOri") - self.populateCheck(self.settingsTab.centralTangent_checkBox, - "centralTangent") + self.populateCheck( + self.settingsTab.centralTangent_checkBox, "centralTangent" + ) def create_componentLayout(self): @@ -195,55 +211,84 @@ def create_componentLayout(self): def create_componentConnections(self): self.settingsTab.softness_slider.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.softness_slider, - "softness")) + partial( + self.updateSlider, self.settingsTab.softness_slider, "softness" + ) + ) self.settingsTab.softness_spinBox.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.softness_spinBox, - "softness")) + partial( + self.updateSlider, + self.settingsTab.softness_spinBox, + "softness", + ) + ) self.settingsTab.position_slider.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.position_slider, - "position")) + partial( + self.updateSlider, self.settingsTab.position_slider, "position" + ) + ) self.settingsTab.position_spinBox.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.position_spinBox, - "position")) + partial( + self.updateSlider, + self.settingsTab.position_spinBox, + "position", + ) + ) self.settingsTab.lockOri_slider.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.lockOri_slider, - "lock_ori")) + partial( + self.updateSlider, self.settingsTab.lockOri_slider, "lock_ori" + ) + ) self.settingsTab.lockOri_spinBox.valueChanged.connect( - partial(self.updateSlider, - self.settingsTab.lockOri_spinBox, - "lock_ori")) + partial( + self.updateSlider, self.settingsTab.lockOri_spinBox, "lock_ori" + ) + ) self.settingsTab.maxStretch_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxStretch_spinBox, - "maxstretch")) + partial( + self.updateSpinBox, + self.settingsTab.maxStretch_spinBox, + "maxstretch", + ) + ) self.settingsTab.maxSquash_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.maxSquash_spinBox, - "maxsquash")) + partial( + self.updateSpinBox, + self.settingsTab.maxSquash_spinBox, + "maxsquash", + ) + ) self.settingsTab.division_spinBox.valueChanged.connect( - partial(self.updateSpinBox, - self.settingsTab.division_spinBox, - "division")) + partial( + self.updateSpinBox, + self.settingsTab.division_spinBox, + "division", + ) + ) self.settingsTab.autoBend_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.autoBend_checkBox, - "autoBend")) + partial( + self.updateCheck, + self.settingsTab.autoBend_checkBox, + "autoBend", + ) + ) self.settingsTab.IKWorldOri_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.IKWorldOri_checkBox, - "IKWorldOri")) + partial( + self.updateCheck, + self.settingsTab.IKWorldOri_checkBox, + "IKWorldOri", + ) + ) self.settingsTab.centralTangent_checkBox.stateChanged.connect( - partial(self.updateCheck, - self.settingsTab.centralTangent_checkBox, - "centralTangent")) + partial( + self.updateCheck, + self.settingsTab.centralTangent_checkBox, + "centralTangent", + ) + ) self.settingsTab.squashStretchProfile_pushButton.clicked.connect( - self.setProfile) + self.setProfile + ) def dockCloseEventTriggered(self): pyqt.deleteInstances(self, MayaQDockWidget)