def createObjects(self): # TRANSFORMATION rootTfm = self.transforms("Rail") posTfm = self.transforms("Pos") negTfm = self.transforms("Neg") for i, (root, pos, neg) in enumerate(izip(rootTfm, posTfm, negTfm), start=1): root.scale = self.scales("Rail{}".format(i)) pos.scale = self.scales("Pos{}".format(i)) neg.scale = self.scales("Neg{}".format(i)) # CONTROLLERS self._rails = [] self._psts = [] self._ngts = [] self._slds = [] self._bfrs = [] for i, (rtfm, ptfm, ntfm) in enumerate(izip(rootTfm, posTfm, negTfm), start=1): rail = self.addRig(None, "Rail{}".format(i), rtfm, "cube", size=1) pos = self.addRig(rail, "Pos{}".format(i), ptfm, "null", size=1) neg = self.addRig(rail, "Neg{}".format(i), ntfm, "cube", size=1) bfr = self.addBfr(rail, "Slider{}".format(i), rtfm) if self.settings("addControllers"): slider = self.addCtl(bfr, "Part{}".format(i), rtfm, "sphere", color=self.colorIk()) attributes.setKeyables(slider) else: slider = self.addRig(bfr, "Part{}".format(i), rtfm, "sphere", size=1) create.cnsCurve("Crv{}".format(i), [neg, rail, pos], degree=1) self._bfrs.append(bfr) self._rails.append(rail) self._slds.append(slider) self._psts.append(pos) self._ngts.append(neg)
def addMarkerDispCurve(self, part, markers): '''Create a display curve. This is just a curve constrained to the markers to help visualize there relation Args: part (str): Unique part of the system object markers (list of str): Returns: str: The constrained curve ''' curve = create.cnsCurve(self.getMarkerName(part), markers, degree=1) cmds.setAttr(curve+".template", True) return curve
def createObjects(self): # Settings self.isFk = "FK" in self.settings("kinematic") self.isIk = "IK" in self.settings("kinematic") self.isFkIk = self.isFk and self.isIk self.isNotIk = self.isFk and not self.isIk self.isNotFk = not self.isFk and self.isIk size = self.translations("Part")[0].distance(self.translations("Part")[1]) * 0.25 # TRANSFORMATION # Normal if self.count("Part") > 2: normal = Vector3.planeNormal(*self.translations("Part")[:3]) direction = self.translations("Part")[-1] - self.translations("Part")[0] if normal.length() < 1E-6: normal = self.directions("Part1", "z") if self.negate(): normal *= -1 else: direction = self.directions("Part1", "x") normal = self.directions("Part1", "z") boneTfm = TransformationArray.chain(self.translations("Part"), normal, negativeSide=self.negate(), endTransform=False) d = [(self.translations("Part")[i],self.translations("Part")[i+1]) for i in range(self.count("Part")-1)] self.distances = [Vector3.distance(a,b) for a,b in d] endTfm = boneTfm[-1].copy(translation=self.translations("Part")[-1]) boneTfm = boneTfm.appended(endTfm) self.distances.append(0.0) # Create extra transforms on end points for i in xrange(self.settings("extraControllers")): extraPos = Vector(self.settings("extraControllerSpacing")*(i+1),0,0) * endTfm extraTfm = endTfm.copy(translation=extraPos) boneTfm = boneTfm.appended(extraTfm) self.distances.append(0.0) self.setSettings(count=len(self.distances), lengths=self.distances) self.initialCount = self.count("Part") if self.settings("setNeutralPose"): bfrTfm = boneTfm else: bfrTfm = [tfm.copy(rotation=boneTfm[max(i-1,0)].quaternion) for i, tfm in enumerate(boneTfm)] if self.settings("dynamic"): dynTfm = [] for i, posA in enumerate(self.translations()[:-1]): posB = self.translations()[i+1] dynTfm.append(Transform.LookingAt(posA, posB, normal, self.nsign()+"yz", self.negate())) self.normal = normal.copy() self.normal.normalize() self.direction = direction.copy() self.direction.normalize() # OBJECTS # Root rootBfr = self.addBfr(None, "Root", tfm=boneTfm[0]) if self.settings("addRootCtrl"): self._root = self.addCtl(rootBfr, "Root", boneTfm[0], "sphere", size=size*1.5, color=self.colorFk()) else: self._root = rootBfr # FK Controllers ----------------------------------------- if self.isFk: self.fkBfr = [] self.fkCtl = [] parent = self._root for i, (tfm, btfm, dist) in enumerate(izip(boneTfm, bfrTfm, self.distances), start=1): if self.negate(): dist *= -1 fkBfr = self.addBfr(parent, "Fk{}".format(i), tfm=btfm) fkCtl = self.addCtl(fkBfr, "Fk{}".format(i), tfm, "cube", po=[dist*0.5,0,0], so=[dist*0.9,size,size], color=self.colorFk()) # self.setInversedsettings(fkCtl, middle=["posz", "rotx", "roty"]) attributes.setRotOrder(fkCtl, self.settings("defaultRotationOrder")) parent = fkCtl self.fkBfr.append(fkBfr) self.fkCtl.append(fkCtl) else: self.fkCtl = len(boneTfm) * [None] # IK Controllers -------------------------------------- if self.isIk: self.ikBfr = [] self.ikCtl = [] self.ikRoot = self.addBfr(self._root, "IkRoot", boneTfm[0]) for i, (tfm, btfm) in enumerate(izip(boneTfm, bfrTfm), start=1): if i == 1: parent = self._root else: parent = self.ikRoot ikBfr = self.addBfr(parent, "Ik{}".format(i), tfm=btfm) ikCtl = self.addCtl(ikBfr, "Ik{}".format(i), tfm, "sphere", size=size, color=self.colorIk()) # self.setInversedsettings(ikCtl, middle=["posz","rotx","roty"]) attributes.setRotOrder(ikCtl, self.settings("defaultRotationOrder")) self.ikBfr.append(ikBfr) self.ikCtl.append(ikCtl) else: self.ikCtl = len(boneTfm) * [None] # Bones ------------------------------- if self.isFkIk or (self.isFk and self.settings("dynamic")): self.bones = [] parent = self._root for i, (tfm, dist) in enumerate(izip(boneTfm, self.distances), start=1): if self.negate(): dist *= -1 bone = self.addRig(parent, "Bone{}".format(i), tfm, "cube", size=1, po=[dist*.5,0,0], so=[0,.5 * size,.5 * size]) self.bones.append(bone) parent = bone elif self.isFk: self.bones = self.fkCtl else: self.bones = self.ikCtl # Dynamic ---------------------------- if self.settings("dynamic"): self.dfmHost = [] self.dynCns = [] self.target = [] self.harmonic = [] self.dynBone = [] parent = self._root for i, (bone, tfmA, tfmB) in enumerate(izip(self.bones[:-1], boneTfm[:-1], boneTfm[1:]), start=1): dynCns = self.addRig(parent, "DynCns{}".format(i), tfmA, "cube", size=1) self.dynCns.append(dynCns) target = self.addRig(dynCns, "Target{}".format(i), tfmB, "null", size=1) self.target.append(target) harmonic = self.addRig(target, "Harmonic{}".format(i), tfmB, "diamond", size=1) self.harmonic.append(harmonic) dynBone = self.addRig(parent, "Dynamic{}".format(i), tfmA, "pyramid", size=1, ro=[0,0,-90], so=[1,self.factor(),1]) self.dynBone.append(dynBone) parent = dynBone self.dfmHost.append(dynBone) # Add the tip, since the tentacle has the tip dynBone = self.addRig(parent, "Dynamic{}".format(len(self.bones)), boneTfm[-1], "pyramid", size=1, ro=[0,0,-90], so=[1,self.factor(),1]) self.dynBone.append(dynBone) self.dfmHost.append(dynBone) else: self.dfmHost = self.bones # Roll Controllers ---------------------------- self.rollBfr = [] self.rollCtl = [] # self.upv = [] if self.settings("addRoll"): for i, (bone, tfm) in enumerate(izip(self.dfmHost, boneTfm), start=1): if self.negate(): rollScl = -2 else: rollScl = 2 rollBfr = self.addBfr(bone, "Roll{}".format(i), tfm=tfm) rollCtl = self.addCtl(rollBfr, "Roll{}".format(i), tfm, "pyramid", size=size, so=[1,rollScl,0], color=self.colorIk()) # self.setInversedsettings(rollCtl, middle=["posz","rotx","roty"]) attributes.setRotOrder(rollCtl, self.settings("defaultRotationOrder")) attributes.setKeyables(rollCtl, ["rotx"]) # self.addToSubControllers(rollCtl) upvPar = rollCtl self.rollBfr.append(rollBfr) self.rollCtl.append(rollCtl) # UI Hosts ---------------------------- self.hosts = [] for i, (bone, btfm) in enumerate(izip(self.dfmHost, boneTfm), start=1): host = self.addCtl(bone, "Host{}".format(i), btfm, "gear", size=size*1.5, color=self.colorFk()) attributes.setKeyables(host, []) self.hosts.append(host) # Tangents ---------------------------- self.tangentBfr = [] self.tangentSolvers = [] self.tangentCtl = [] self.tanCrvs = [] points = [] for i, (bone, btfm, dist) in enumerate(izip(self.dfmHost, boneTfm, self.distances)): tanBfrs = [] tanSolvers = [] tanCtls = [] if i: tangent = self._createTangentObjects("InTangent", i, size, bone, btfm, -self.distances[i-1]*0.333, "cube") tanBfrs.append(tangent[0]) tanSolvers.append(tangent[1]) tanCtls.append(tangent[2]) else: tanBfrs.append(None) tanSolvers.append(None) tanCtls.append(None) if i != len(self.bones)-1: tangent = self._createTangentObjects("OutTangent", i, size, bone, btfm, dist*0.333, "diamond") tanBfrs.append(tangent[0]) tanSolvers.append(tangent[1]) tanCtls.append(tangent[2]) else: tanBfrs.append(None) tanSolvers.append(None) tanCtls.append(None) self.tangentBfr.append(tanBfrs) self.tangentSolvers.append(tanSolvers) self.tangentCtl.append(tanCtls) # Draw helper lines for the tangents. Start by filtering out empty entries from the centers list centers = [item for item in [tanCtls[0], bone, tanCtls[1]] if item] tanCrv = create.cnsCurve("TanCrv{}".format(i+1), centers, degree=1) cmds.setAttr(tanCrv+".template", True) self.tanCrvs.append(tanCrv) # Curve ---------------------------- self.curvePar = self.addRig(None, "Curve") cmds.setAttr(self.curvePar+".template", True)
def createObjects(self): # TRANSFORMATIONS positions = Vector3Array([ self.translations("Root"), self.translations("Knee"), self.translations("Ankle"), self.translations("Toe") ]) normal = Vector3.planeNormal(*positions[:3]) oriNormal = normal.copy() if self.negate(): normal *= -1 d = [(positions[i], positions[i + 1]) for i in range(3)] self.lengths = [Vector3.distance(a, b) for a, b in d] self.lengths.append(1) ratio = self.lengths[0] / sum(self.lengths[:2]) self.setSettings(lengths=self.lengths[:3]) # root rootTfm = Transformation.fromParts( translation=self.translations("Root")) # fk fkTfm = TransformationArray.chain(positions, normal, axis="xz", negativeSide=self.negate(), endTransform=False) lookAtEff = self.translations("Eff") - self.translations("Toe") fk3Tfm = Transformation.lookAt(self.translations("Toe"), lookAtEff, constants.AXIS_Y, "y-x", self.negate()) fkTfm = fkTfm.appended(fk3Tfm) for tfm, dist in izip(fkTfm, self.lengths): tfm.scale = Vector3( [dist * self.factor(), self.factor(), self.factor()]) bfrTfm = [ tfm.copy(rotation=fkTfm[max(i - 1, 0)].rotation) for i, tfm in enumerate(fkTfm) ] bfrTfm[0] = Transformation.lookAt(self.translations("Root"), constants.AXIS_NY, constants.AXIS_X, "x" + self.nsign() + "z", self.negate()) scale = bfrTfm[0].scale scale.x *= self.lengths[0] bfrTfm[0].scale = scale # ik ikbfrPos = Vector3([ self.translations("Root").x, self.translations("Toe").y, self.translations("Root").z ]) ikbfrTfm = Transformation.fromParts(translation=ikbfrPos) ikTfm = Transformation.lookAt(self.translations("Toe"), lookAtEff, constants.AXIS_Y, "zy", False) upvbfrTfm = Transformation.fromParts( translation=umath.upVector(self.translations("Root"), ikbfrPos, constants.AXIS_NX, ratio, False)) upvTfm = Transformation.fromParts( translation=umath.upVector(self.translations( "Root"), self.translations("Ankle"), oriNormal, ratio)) rollNormal = Vector3.planeNormal(self.translations("Root"), upvTfm.translation, self.translations("Toe")) if self.negate(): rollNormal *= -1 direction = self.translations("Root") - self.translations("Toe") rollbfrTfm = Transformation.lookAt(self.translations("Toe"), direction, rollNormal, "y-x", self.negate()) direction = self.translations("Ankle") - self.translations("Toe") rollTfm = Transformation.lookAt(self.translations("Toe"), direction, normal, "y-x", self.negate()) # extras scale = Vector3([self.factor(), self.factor(), self.factor()]) twisterTfm = {} interTfm = {} for i, (p, pos) in enumerate(izip(self.twp, positions[1:4])): twisterTfm[p] = [ fkTfm[i].copy(scale=scale), fkTfm[i].copy(translation=pos, scale=scale) ] interPos = twisterTfm[p][0].translation.lerp( twisterTfm[p][1].translation, .5) interTfm[p] = twisterTfm[p][0].copy(translation=interPos) ctrATfm = twisterTfm["Mid"][0] ctrBTfm = twisterTfm["Lwr"][0] # CONTROLLERS # Root self.rootBfr = self.addBfr(None, "Root", rootTfm) self.rootCtl = self.addCtl(self.rootBfr, "Root", rootTfm, "sphere", size=4, color=self.colorIk()) # self.addToSubControllers(self.rootCtl) attributes.setKeyables(self.rootCtl, constants.ATTRS_T) # self.setInversedParameters(self.rootCtl, middle=["posx"], side=["posx"]) # Fk Ref # Used as a reference for the upr start twist # We cannot use the fk1Bfr cause this one get constrained when fk ref changes self.fkRef = self.addRig(self.rootBfr, "FkRef", bfrTfm[0]) # FK Controlers and Bones fkParent = self.fkRef boneParent = self.fkRef self.fkBfr = [] self.fkCtl = [] self.bones = [] self.stretches = [] for i, (tfm, btfm) in enumerate(izip(fkTfm, bfrTfm), start=1): bfr = self.addBfr(fkParent, "Fk%s" % i, btfm) ctl = self.addCtl(bfr, "Fk%s" % i, tfm, "sphere", size=8, so=[0, 1, 1], color=self.colorFk()) if self.settings("lockKneeRotation") and i == 2: keyables = [ "posx", "posy", "posz", "rotz", "sclx", "scly", "sclz" ] else: keyables = constants.ATTRS_TRS if i == 1: attributes.setRotOrder(ctl, "XZY") attributes.setKeyables(ctl, keyables) # self.setInversedParameters(ctl, middle=["posz", "roty", "rotx"]) fkParent = ctl self.fkBfr.append(bfr) self.fkCtl.append(ctl) bone = self.addRig(boneParent, "Bone{}".format(i), tfm=tfm, icon="bone", so=(self.factor(), 1, 1)) boneParent = bone self.bones.append(bone) # IK Controllers self.rollBfr = self.addBfr(self.rootBfr, "Roll", rollbfrTfm) self.rollCtl = self.addCtl(self.rollBfr, "Roll", rollTfm, "jaw", size=1, ro=(-90, 0, 0), color=self.colorIk()) #self.rollCtl = self.addCtl(self.rollBfr, "Roll", rollTfm, "jaw", size=2, po=(4,6,0), color=self.colorIk()) # self.setNeutralPose(self.rollCtl) attributes.setKeyables(self.rollCtl, ["rotx", "roty", "rotz", "rotorder", "scly"]) self.ikRef = self.addRig(self.rollCtl, "IkRef", fkTfm[-2]) self.ikBfr = self.addBfr(None, "Ik", ikbfrTfm) self.ikCtl = self.addCtl(self.ikBfr, "Ik", ikTfm, "cube", size=6, color=self.colorIk()) attributes.setKeyables(self.ikCtl, constants.ATTRS_TRS) # self.setInversedParameters(self.ikCtl, middle=["posx", "rotz", "roty"], side=["posx", "rotz", "roty"]) attributes.setRotOrder(self.ikCtl, "XZY") self.ikoffCtl = self.addCtl(self.ikCtl, "IkOffset", ikTfm, "null", size=4, color=self.colorIk()) # self.addToSubControllers(self.ikoffCtl) attributes.setKeyables(self.ikoffCtl, constants.ATTRS_TRS) # self.setInversedParameters(self.ikoffCtl, middle=["posx", "rotz", "roty"], side=["posx", "rotz", "roty"]) attributes.setRotOrder(self.ikoffCtl, "XZY") self.upvBfr = self.addBfr(None, "Upv", upvbfrTfm) self.upvCtl = self.addCtl(self.upvBfr, "Upv", upvTfm, "diamond", size=2, color=self.colorIk()) attributes.setKeyables(self.upvCtl, constants.ATTRS_T) # self.setInversedParameters(self.upvCtl, middle=["posx"], side=["posx"]) self.ctrABfr = self.addBfr(self.bones[0], "CenterA", ctrATfm) self.ctrACtl = self.addCtl(self.ctrABfr, "CenterA", ctrATfm, "sphere", size=5, color=self.colorIk()) # self.addToSubControllers(self.ctrACtl) attributes.setKeyables(self.ctrACtl, constants.ATTRS_TRS) # self.setInversedParameters(self.ctrACtl, middle=["posz", "roty", "rotx"]) self.ctrBBfr = self.addBfr(self.bones[1], "CenterB", ctrBTfm) self.ctrBCtl = self.addCtl(self.ctrBBfr, "CenterB", ctrBTfm, "sphere", size=5, color=self.colorIk()) # self.addToSubControllers(self.ctrBCtl) attributes.setKeyables(self.ctrBCtl, constants.ATTRS_TRS) # self.setInversedParameters(self.ctrBCtl, middle=["posz", "roty", "rotx"]) self.upvCrv = create.cnsCurve( self.getObjectName(config.USE_RIG, "UpvCrv"), [self.upvCtl, self.ctrACtl]) cmds.setAttr(self.upvCrv + ".template", True) self.footRef = self.addRig(self.ikoffCtl, "FootRef", ikTfm) # Twisters self.twisters = defaultdict(list) for p in self.twp: for s, tfm, factor in izip(["Start", "End"], twisterTfm[p], [1, -1]): twister = self.addRig(self.rootBfr, "Tw" + p + s, tfm, "sphere", po=[factor, 0, 0], so=[2, 1, 1]) # self.setNeutralPose(twister) self.twisters[p].append(twister) # Inter self.inters = {} for p in self.twp: self.inters[p] = self.addRig(self.rootBfr, "Inter" + p, interTfm[p], "pyramid")
def createObjects(self): # Settings self.isFk = "FK" in self.settings("kinematic") self.isIk = "IK" in self.settings("kinematic") self.isFkIk = self.isFk and self.isIk # TRANSFORMATION # Positions positions = self.translations("Part") # Normal if self.count("Part") > 2: normal = Vector3.planeNormal(*positions[:3]) if normal.length() < 1E-6: normal = self.directions("Part1", "z") if self.negate(): normal *= -1 else: normal = self.directions("Part1", "z") boneTfm = TransformationArray.chain(positions, normal, axis="xz", negativeSide=self.negate(), endTransform=False) d = [(positions[i], positions[i + 1]) for i in range(self.count("Part") - 1)] boneLen = [Vector3.distance(a, b) for a, b in d] self.setSettings(count=len(boneLen), lengths=boneLen) if self.settings("setNeutralPose"): bfrTfm = boneTfm else: bfrTfm = [ tfm.copy(rotation=boneTfm[max(i - 1, 0)].rotation) for i, tfm in enumerate(boneTfm) ] if self.isIk: ikTfm = boneTfm[-1].copy(translation=positions[-1]) # Up Vector if self.count("Part") > 2: upvTfm = Transformation.fromParts( translation=umath.upVector(positions[0], positions[2], normal, ratio=1, negate=self.negate())) else: upvTfm = Transformation.fromParts( translation=umath.upVector(positions[0], positions[1], normal, ratio=1, negate=self.negate())) if self.settings("dynamic"): tgtTfm = boneTfm[1:] tgtTfm = tgtTfm.appended( boneTfm[-1].copy(translation=positions[-1])) # OBJECTS # Root self._root = self.addRig(None, "Root", tfm=boneTfm[0]) # FK Controllers ----------------------------------------- if self.isFk: self.fkBfr = [] self.fkCtl = [] self.fkDir = [] parent = self._root for i, (tfm, btfm, dist) in enumerate(izip(boneTfm, bfrTfm, boneLen), start=1): fkBfr = self.addBfr(parent, "Fk{}".format(i), tfm=btfm) fkCtl = self.addCtl(fkBfr, "Fk{}".format(i), tfm, "sphere", so=[0, 1, 1], color=self.colorFk()) # self.setInversedsettings(fkCtl, middle=["posz", "rotx", "roty"]) attributes.setRotOrder(fkCtl, self.settings("defaultRotationOrder")) parent = fkCtl self.fkBfr.append(fkBfr) self.fkCtl.append(fkCtl) bone = self.addRig(fkCtl, "Dir{}".format(i), tfm, "pyramid", size=1, ro=[0, 0, -90], so=[.5, self.factor() * dist, .5]) self.fkDir.append(bone) # Add the end reference for ikfk matching tfm = boneTfm[-1].copy(translation=positions[-1]) self._tip = self.addRig(self.fkCtl[-1], "Tip", tfm) # IK Controllers -------------------------------------- if self.isIk: # Ik Controller self.ikBfr = self.addBfr(self._root, "Ik", tfm=ikTfm) self.ikCtl = self.addCtl(self.ikBfr, "Ik", ikTfm, "cube", size=2, color=self.colorIk()) attributes.setKeyables(self.ikCtl, constants.ATTRS_TR) # UpVector Controller self.upvBfr = self.addBfr(self._root, "UpV", upvTfm) self.upvCtl = self.addCtl(self.upvBfr, "UpV", upvTfm, "diamond", color=self.colorIk()) attributes.setKeyables(self.upvCtl, constants.ATTRS_T) # Ik Chain self.ikBones, self.effector, self.handle = create.chain( self.getObjectName(config.USE_RIG, "Ik"), self._root, positions, normal, negate=self.negate()) self.upvCrv = create.cnsCurve( [self.ikChn.root(), self.upvCtl, self.ikChn.effector()], "UpvCrv") cmds.setAttr(self.upvCrv + ".template", True) # Bones ------------------------------- if self.isFkIk: # or (self.isFk and self.settings("dynamic")): self.bones = [] parent = self._root for i, (tfm, dist) in enumerate(izip(boneTfm, boneLen), start=1): bone = self.addRig(parent, "Bone{}".format(i), tfm, "cube", size=1, po=[self.factor() * dist * .5, 0, 0], so=[dist, .5, .5]) self.bones.append(bone) parent = bone elif self.isFk: self.bones = self.fkCtl else: self.bones = self.ikChn.bones() # Dynamic ---------------------------- if self.settings("dynamic"): self.dfmHost = [] self.dynCns = [] self.target = [] self.harmonic = [] self.dynBone = [] parent = self._root for i, (bone, tfmA, tfmB) in enumerate(izip(self.bones, boneTfm, tgtTfm), start=1): dynCns = self.addRig(parent, "DynCns{}".format(i), tfmA, "cube", size=1) self.dynCns.append(dynCns) target = self.addRig(dynCns, "Target{}".format(i), tfmB, "null", size=1) self.target.append(target) harmonic = self.addRig(target, "Harmonic{}".format(i), tfmB, "diamond", size=1) self.harmonic.append(harmonic) dynBone = self.addRig(parent, "Dynamic{}".format(i), tfmA, "pyramid", size=1, ro=[0, 0, -90], so=[1, self.factor(), 1]) self.dynBone.append(dynBone) parent = dynBone self.dfmHost.append(dynBone) else: self.dfmHost = self.bones # Strap ---------------------------- if self.settings("strap"): endTfm = boneTfm[-1].copy(translation=positions[-1]) self.end = self.addRig(self.dfmHost[-1], "End", endTfm)
def createObjects(self): self.axis = self.settings("axis").lower() # TRANSFORMATIONS positions = self.translations("Part") # Normal if self.count("Part") > 2: normal = Vector3.planeNormal(*positions[:3]) if normal.length() < 1E-6: normal = self.directions("Part1", "z") else: normal = self.directions("Part1", "z") ctlTfm = TransformationArray.chain(positions, normal, axis=self.axis+"z", negativeSide=self.negate(), endTransform=True) divTfm = Transformation() if self.negate(): divTfm.scaling = Vector3([-1,-1,-1]) length = self.translations("Part1").distance(self.translations("Part2")) / 5.0 # CONTROLLERS self._centers = [] # Left this dictionary in here, just in case we wanna revert back shdScl = [length,length,length] shdScl["xyz".index(self.axis)] = 0 se_keyableParameters = list(constants.ATTRS_TR) int_keyableParameters = list(constants.ATTRS_T) if self.settings("scaleWithControllers"): se_keyableParameters += ["scl"+s for s in "xyz" if s != self.axis] if self.settings("scaleWithInterControllers"): int_keyableParameters += ["scl"+s for s in "xyz" if s != self.axis] # Start Controller bfr = self.addBfr(None, "Start", ctlTfm[0]) if self.settings("startController"): ctl = self.addCtl(bfr, "Start", ctlTfm[0], "sphere", so=shdScl, color=self.colorFk()) attributes.setKeyables(ctl, se_keyableParameters) self._centers.append(ctl) else: self._centers.append(bfr) # Inter Controller for i, tfm in enumerate(ctlTfm[1:-1], start=1): bfr = self.addBfr(None, "Part%s"%i, tfm) if self.settings("interControllers"): ctl = self.addCtl(bfr, "Part%s"%i, tfm, "cube", size=2, so=shdScl, color=self.colorFk()) attributes.setKeyables(ctl, int_keyableParameters) self._centers.append(ctl) else: self._centers.append(bfr) # End Controller bfr = self.addBfr(None, "End", ctlTfm[-1]) if self.settings("endController"): ctl = self.addCtl(bfr, "End", ctlTfm[-1], "sphere", so=shdScl, color=self.colorFk()) attributes.setKeyables(ctl, se_keyableParameters) self._centers.append(ctl) else: self._centers.append(bfr) # CURVE # tangent = self.settings("tangentDistance") if self.settings("tangent") else None self.crv = create.cnsCurve(self.getObjectName(config.USE_RIG, "Crv"), self._centers, closed=False, degree=3) self.length = cmds.arclen(self.crv) # DIVISIONS parent = self._centers[0] self.start_iter = 0 if self.settings("startDeformer") and not self.settings("tangent") else 1 if self.settings("tangent"): self.interDiv = [self.addRig(parent, "Div%s"%i, divTfm, "cube", size=2) for i in xrange(1, self.settings("interDeformers")+1)] if self.settings("untwistDeformers"): self.unTwistDiv = [self.addRig(parent, "Untwist%s"%i, divTfm, "cube", size=1) for i in xrange(1, self.settings("interDeformers")+1)] self.unTwistStart = self.addRig(self._centers[0], "UntwistStart", ctlTfm[0], "cube", size=1) self.unTwistEnd = self.addRig(self._centers[-1], "UntwistEnd", ctlTfm[-1], "cube", size=1) else: div_count = self.settings("interDeformers") + self.settings("startDeformer") + self.settings("endDeformer") self.interDiv = [self.addRig(parent, "Div%s"%i, divTfm, "cube", size=2) for i in xrange(self.start_iter, div_count+self.start_iter)] if self.settings("untwistDeformers"): self.unTwistDiv = [self.addRig(parent, "Untwist%s"%i, divTfm, "cube", size=1) for i in xrange(self.start_iter, div_count+self.start_iter)]
def createObjects(self): # SIZE size = self.translations("Root").distance(self.translations("Knee")) fkSize = size * .25 ikSize = size * .25 upvSize = size * .1 rootSize = size * .15 # TRANSFORMATIONS positions = Vector3Array([ self.translations("Root"), self.translations("Knee"), self.translations("Ankle") ]) normal = Vector3.planeNormal(*positions) oriNormal = normal.copy() if self.negate(): normal *= -1 isInversed = constants.AXIS_X.dot(oriNormal) >= 0 d = [(positions[i], positions[i + 1]) for i in range(2)] self.lengths = [Vector3.distance(a, b) for a, b in d] self.lengths.append(1) ratio = self.lengths[0] / sum(self.lengths[:2]) self.setSettings(lengths=self.lengths[:2]) # root rootTfm = Transformation.fromParts( translation=self.translations("Root")) # fk fkTfm = TransformationArray.chain(positions, normal, axis="xz", negativeSide=self.negate(), endTransform=False) axis = "-y-x" if isInversed else "y-x" if self.settings("ankleUpVector") == "World Y": upaxis = constants.AXIS_Y else: upaxis = -1 * self.directions("Ankle", "z") direction = self.translations("Eff") - self.translations("Ankle") fk2Tfm = Transformation.lookAt(self.translations("Ankle"), direction, upaxis, axis, self.negate()) fkTfm = fkTfm.appended(fk2Tfm) bfrTfm = [ tfm.copy(rotation=fkTfm[max(i - 1, 0)].rotation) for i, tfm in enumerate(fkTfm) ] xaxis = constants.AXIS_NX if isInversed else constants.AXIS_X bfrTfm[0] = Transformation.lookAt(self.translations("Root"), constants.AXIS_NY, xaxis, "x" + self.nsign() + "z", self.negate()) # ik ikbfr_pos = Vector3([ self.translations("Root").x, self.translations("Ankle").y, self.translations("Root").z ]) ikbfrTfm = Transformation.fromParts(translation=ikbfr_pos) ikTfm = Transformation.lookAt(self.translations("Ankle"), direction, upaxis, "zy", False) upvbfrTfm = Transformation.fromParts( translation=umath.upVector(self.translations("Root"), ikbfr_pos, constants.AXIS_NX, ratio, False)) upvTfm = Transformation.fromParts( translation=umath.upVector(self.translations( "Root"), self.translations("Ankle"), oriNormal, ratio)) # extras scale = Vector3([1, 1, 1]) twisterTfm = {} interTfm = {} for i, (p, pos) in enumerate(izip(self.twp, positions[1:3])): twisterTfm[p] = [ fkTfm[i].copy(scale=scale), fkTfm[i].copy(translation=pos, scale=scale) ] inter_pos = twisterTfm[p][0].translation.lerp( twisterTfm[p][1].translation, .5) interTfm[p] = twisterTfm[p][0].copy(translation=inter_pos) ctrTfm = twisterTfm["Lwr"][0] # CONTROLLERS # Root self.rootBfr = self.addBfr(None, "Root", rootTfm) self.rootCtl = self.addCtl(self.rootBfr, "Root", rootTfm, "sphere", color=self.colorIk(), size=rootSize) # self.addToSubControllers(self.rootCtl) attributes.setKeyables(self.rootCtl, constants.ATTRS_T) # Fk Ref # Used as a reference for the upr start twist # We cannot use the fk1Bfr cause this one get constrained when fk ref changes self.fkRef = self.addRig(self.rootBfr, "FkRef", bfrTfm[0]) # FK Controlers and Bones fkParent = self.fkRef boneParent = self.fkRef self.fkBfr = [] self.fkCtl = [] self.bones = [] self.stretches = [] for i, (tfm, btfm) in enumerate(izip(fkTfm, bfrTfm), start=1): bfr = self.addBfr(fkParent, "Fk%s" % i, btfm) ctl = self.addCtl(bfr, "Fk%s" % i, tfm, "sphere", color=self.colorFk(), size=fkSize, so=(0, 1, 1)) if self.settings("lockKneeRotation") and i == 2: keyableParams = [ "posx", "posy", "posz", "rotz", "sclx", "scly", "sclz" ] else: keyableParams = constants.ATTRS_TRS attributes.setKeyables(ctl, keyableParams) fkParent = ctl self.fkBfr.append(bfr) self.fkCtl.append(ctl) bone = self.addRig(boneParent, "Bone{}".format(i), tfm=tfm, icon="bone", so=(self.factor(), 1, 1)) boneParent = bone self.bones.append(bone) # IK Controllers self.ikBfr = self.addBfr(None, "Ik", ikbfrTfm) self.ikCtl = self.addCtl(self.ikBfr, "Ik", ikTfm, "cube", color=self.colorIk(), size=ikSize) attributes.setKeyables(self.ikCtl, constants.ATTRS_TRS) attributes.setRotOrder(self.ikCtl, "XZY") self.ikoffCtl = self.addCtl(self.ikCtl, "IkOffset", ikTfm, "cube", color=self.colorIk(), size=ikSize) # self.addToSubControllers(self.ikoffCtl) attributes.setKeyables(self.ikoffCtl, constants.ATTRS_TRS) self.ikRef = self.addRig(self.ikoffCtl, "IkRef", fkTfm[-1]) attributes.setRotOrder(self.ikoffCtl, "XZY") self.upvBfr = self.addBfr(None, "Upv", upvbfrTfm) self.upvCtl = self.addCtl(self.upvBfr, "Upv", upvTfm, "diamond", color=self.colorIk(), size=upvSize) attributes.setKeyables(self.upvCtl, constants.ATTRS_T) self.ctrBfr = self.addBfr(self.bones[0], "Center", ctrTfm) self.ctrCtl = self.addCtl(self.ctrBfr, "Center", ctrTfm, "sphere", size=rootSize, color=self.colorIk()) # self.addToSubControllers(self.ctrCtl) attributes.setKeyables(self.ctrCtl, constants.ATTRS_TRS) self.upvCrv = create.cnsCurve( self.getObjectName(config.USE_RIG, "UpvCrv"), [self.upvCtl, self.ctrCtl]) # Twisters self.twisters = defaultdict(list) for p in self.twp: for s, tfm, factor in izip(["Start", "End"], twisterTfm[p], [1, -1]): twisterBfr = self.addBfr(self.rootBfr, "Tw" + p + s, tfm) twister = self.addRig(twisterBfr, "Tw" + p + s, tfm, "pyramid") self.twisters[p].append(twister) # Inter self.inters = {} for p in self.twp: self.inters[p] = self.addRig(self.rootBfr, "Inter" + p, interTfm[p], "cube")