Animation and Rigging Tools: FAQ, Known Issues and Feature Roadmap

[anonymous_user_a2eb620c]

Hello , i want to know if i can import fbx animation from mixamo and use it. I tried and I faced some problems. It was distorting my char like in the img. I tried to use the same bone as mixamo uses and I got that. Someone cold help me? Is there is any possibilites to import animation from mixamo and apply in my character in ART plugin ? Thanks alot!!!

[CodeSpartan]

@;674168

To export the mesh, right click on it in the Content Browser and select Assets Actions –> Export
Hope this is the thing you’re looking for

I know how to export meshes from unreal, that wasn’t the question.

[anonymous_user_7d8324b51 (anonymous_user_7d8324b5)]

@CodeSpartan;674267

I know how to export meshes from unreal, that wasn’t the question.

Could you please re-explain the problem? If you still need help.

[sieumeo]

Anyone could use Switching Characters function on Mac OS ?

[korekovski]

Hello, everyone, I am working on my project, it is Multiplayer game teams VS teams, It’s made with c++ and I want to edit the soldier movements, I purchased rifle animation pack most and IRbelly weapons pack, the requirements which I need is to Add custom characters plus edit the existing character movements with the Maco animation pack. do not hesitate to contact me on my email address if any programmer interested in fixing My project Issues. korekdesign@gmail.com

[rctorres]

Any news/update on the status of V2? A while back mentioned getting something ready around GDC, was that for the in-engine rigging controls stuff?

[S4intFl0w]

Hi! I would be very interested as well if there is any ETA on having Artv2 in engine. Dived into my first bigger ue4 project and took a look at the workflow with maya and artv1. Seems like having the version in engine will make things WAY easier and WAY more comfortable for prototyping. Any info would be much appreciated, thanks!

[Jakobo48]

ART_skeletonBuilder_UI.py line 11741: invalid literal for int() with base 10: ‘Nothing counted : no polygonal object is selected.’ #

I’m getting the above error anytime I try to return to Skeleton Placement from the Deformation Setup step. It doesn’t matter if any object is selected or not. I’m using Maya 2016 and the A.R.T. from the Unreal Marketplace. I’ve also updated with the files from Dropbox and get the same result. Any thoughts?

Additional Info/Solution Edit:

It appears to be trying to save out weight data for a mover (in this case hair), crashes, and creates a 0KB file with the wrong naming convention in the system folder. If I delete that I can at least start from scratch and load whatever weights it wrote out before hitting that point.

It looks like that mover got caught up in my wild card for binding, so wild card unbinding the movers in the scene got everything working again. Modified my code to specify joints in the Skeleton hierarchy hehe.

[AaronCarlisle]

@lion032;645023

Hi ,

Would it be possible for you check the following code for finger fk/ik matching?
And if it is good I would like to contribute it

in ART_animationUI.py:

    def match_finger_ik(self,character,finger,side,*args):

        fingerJoints = "01_", "02_", "03_"]
        fingerLocators = {}
        for index in fingerJoints:
            fingerLocators[index] = cmds.spaceLocator()[0]
        for index in fingerJoints:
            cmds.delete(cmds.parentConstraint(character + ":driver_"+ finger + index + side, fingerLocators[index])[0])
        
        constraints = {}
        for index in fingerJoints:
            constraints  index ] = cmds.orientConstraint( fingerLocators[index ], character + ":" + finger + "finger_fk_ctrl_" + index[1:] +  side )[0]

        for index in fingerJoints:
            cmds.setKeyframe(character + ":" + finger + "finger_fk_ctrl_" + index[1:] +  side )

 
        for index in fingerJoints:
            cmds.delete(constraints[index])

        for index in fingerJoints:
            cmds.delete(fingerLocators[index])
 
    def getScaleFactor(self,character):
        
        return cmds.getAttr(character + ":" + "Rig_Settings.scaleFactor")
    
   

    def match_finger_fk(self,character, finger,side,scaleFactor ,*args):

            finger01Loc = cmds.spaceLocator()[0]
            finger02Loc = cmds.spaceLocator()[0]
            finger03Loc = cmds.spaceLocator()[0]

            #constrain to the arm driver joints

            cmds.delete(cmds.parentConstraint(character + ":driver_"+ finger + "01_" + side, finger01Loc )[0])
            cmds.delete(cmds.parentConstraint(character + ":driver_"+ finger + "02_" + side, finger02Loc )[0])
            cmds.delete(cmds.parentConstraint(character + ":driver_"+ finger + "03_" + side, finger03Loc )[0])



            #create a fourth locator for the wrist, parent under the handLoc and rotate 90 in X
            fingerOffset = cmds.duplicate(finger03Loc)[0]
            cmds.parent(fingerOffset, finger03Loc)
            if side == "l":
                cmds.setAttr(fingerOffset + ".tx",5*scaleFactor)
            else:
                cmds.setAttr(fingerOffset + ".tx",-5*scaleFactor)
            #if side == "l":
            #    cmds.setAttr(fingerOffset + ".rotateX", 90)
            #else:
            #    cmds.setAttr(fingerOffset + ".rotateX", -90)

            #constrain the elbow control to the elbow locator
            # if cmds.objExists(character + ":elbowswitch_"+side):
            #     ptCnst = cmds.pointConstraint(character + ":elbowswitch_"+side, character + ":ik_elbow_" + side + "_anim")
            #
            # else:

            pntConst = cmds.pointConstraint(finger02Loc , character + ":"+ finger+side + "_poleVector")[0]

            #constrain the wrist
            constraint = cmds.parentConstraint(fingerOffset , character + ":"+ finger + side + "_ik_anim")[0]

            #set keys
            cmds.setKeyframe(character + ":"+ finger+side + "_poleVector")
            cmds.setKeyframe(character + ":"+ finger+ side + "_ik_anim")

    # if cmds.objExists(character + ":elbowswitch_"+side):
    #     cmds.delete(ptCnst)

            cmds.delete(constraint)
            cmds.delete(pntConst)
            cmds.delete(finger01Loc)
            cmds.delete(finger02Loc)
            cmds.delete(finger03Loc)


    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    def match_singleFrame(self, limb, side, matchFrom, matchTo, solveRoll = False, *args):

        autoKeyOn = False
        if cmds.autoKeyframe(q = True, state = True):
            cmds.autoKeyframe(state = False)
            autoKeyOn = True

        #get the passed in limb, and duplicate the skeleton for that limb's current mode
        #for example, if limb is left arm, and matchFrom is IK, then dupe the driver joints (in IK pose) for the left arm and parent to world
        character = cmds.symbolButton(self.widgets"activeCharacterThumb"], q = True, ann = True)

        armBones = "upperarm_", "lowerarm_", "hand_"]
        spineBones = "driver_spine_01", "driver_spine_02", "driver_spine_03", "driver_spine_04", "driver_spine_05"]
        legBones = "thigh_", "calf_", "foot_", "ball_"]
        
        fingerBones = "thumb", "index", "middle", "ring", "pinky"]
        fingerJoints = "01_", "02_", "03_"]        

        #grab current selection
        currentSelection = cmds.ls(sl = True)

        if limb == "fingers":
        
            
            if matchTo == "IK":
                for fingerBone in fingerBones:
                    self.match_finger_ik(character,fingerBone+"_",side)

            if matchTo == "FK":
                
                scaleFactor =  self.getScaleFactor(character)
                
                for fingerBone in fingerBones:
                    self.match_finger_fk(character,fingerBone+"_",side,scaleFactor)
        
        if limb in fingerBones:
            if matchTo == "IK":
                self.match_finger_ik(character, limb+"_",side)
            if matchTo == "FK":
                scaleFactor =  self.getScaleFactor(character)
                self.match_finger_fk(character,limb+"_",side,scaleFactor)
                
                

        #arm matching
        if limb == "arm":
            #setup constraints based on mode info
            if matchTo == "IK":

                #create 3 locators in world space
                upArmLoc = cmds.spaceLocator()[0]
                lowArmLoc = cmds.spaceLocator()[0]
                handLoc = cmds.spaceLocator()[0]

                #constrain to the arm driver joints
                cmds.delete(cmds.parentConstraint(character + ":driver_upperarm_" + side, upArmLoc)[0])
                cmds.delete(cmds.parentConstraint(character + ":driver_lowerarm_" + side, lowArmLoc)[0])
                cmds.delete(cmds.parentConstraint(character + ":driver_hand_" + side, handLoc)[0])

                #constrain FK controls to the locators
                constraint1 = cmds.orientConstraint(upArmLoc, character + ":fk_arm_" + side + "_anim")[0]
                constraint2 = cmds.orientConstraint(lowArmLoc, character + ":fk_elbow_" + side + "_anim")[0]
                constraint3 = cmds.orientConstraint(handLoc, character + ":fk_wrist_" + side + "_anim")[0]

                # constraint1 = cmds.orientConstraint(character + ":ik_upperarm_fk_matcher_" + side, character + ":fk_arm_" + side + "_anim")[0]
                # constraint2 = cmds.orientConstraint(character + ":ik_lowerarm_fk_matcher_" + side, character + ":fk_elbow_" + side + "_anim")[0]
                # constraint3 = cmds.orientConstraint(character + ":hand_match_loc_" + side, character + ":fk_wrist_" + side + "_anim")[0]

                cmds.setKeyframe(character + ":fk_arm_" + side + "_anim")
                cmds.setKeyframe(character + ":fk_elbow_" + side + "_anim")
                cmds.setKeyframe(character + ":fk_wrist_" + side + "_anim")

                cmds.delete(constraint1)
                cmds.delete(constraint2)
                cmds.delete(constraint3)

                cmds.delete(upArmLoc)
                cmds.delete(lowArmLoc)
                cmds.delete(handLoc)



            if matchTo == "FK":


                #create 3 locators in world space
                upArmLoc = cmds.spaceLocator()[0]
                lowArmLoc = cmds.spaceLocator()[0]
                handLoc = cmds.spaceLocator()[0]

                #constrain to the arm driver joints
                cmds.delete(cmds.parentConstraint(character + ":driver_upperarm_" + side, upArmLoc)[0])
                cmds.delete(cmds.parentConstraint(character + ":driver_lowerarm_" + side, lowArmLoc)[0])
                cmds.delete(cmds.parentConstraint(character + ":driver_hand_" + side, handLoc)[0])

                #create a fourth locator for the wrist, parent under the handLoc and rotate 90 in X
                handOffset = cmds.duplicate(handLoc)[0]
                cmds.parent(handOffset, handLoc)
                if side == "l":
                    cmds.setAttr(handOffset + ".rotateX", 90)
                else:
                    cmds.setAttr(handOffset + ".rotateX", -90)

                #constrain the elbow control to the elbow locator
                # if cmds.objExists(character + ":elbowswitch_"+side):
                #     ptCnst = cmds.pointConstraint(character + ":elbowswitch_"+side, character + ":ik_elbow_" + side + "_anim")
                #
                # else:
                pntConst = cmds.pointConstraint(lowArmLoc, character + ":ik_elbow_" + side + "_anim")[0]

                #constrain the wrist
                constraint = cmds.parentConstraint(handOffset, character + ":ik_wrist_" + side + "_anim")[0]

                #set keys
                cmds.setKeyframe(character + ":ik_wrist_" + side + "_anim")
                cmds.setKeyframe(character + ":ik_elbow_" + side + "_anim")

                # if cmds.objExists(character + ":elbowswitch_"+side):
                #     cmds.delete(ptCnst)

                cmds.delete(constraint)
                cmds.delete(pntConst)
                cmds.delete(upArmLoc)
                cmds.delete(lowArmLoc)
                cmds.delete(handLoc)



                # dupeNodes = cmds.duplicate(character + ":driver_" + armBones[0] + side)
                #
                # parent = cmds.listRelatives(dupeNodes[0], parent = True)
                # if parent != None:
                #     cmds.parent(dupeNodes[0], world = True)
                #
                # cmds.pointConstraint("driver_hand_" + side, character + ":ik_wrist_" + side + "_anim")
                # constraint = cmds.orientConstraint(character + ":fk_wrist_" + side + "_anim", character + ":ik_wrist_" + side + "_anim")[0]
                #
                # # CRA NEW CODE - For making sure the elbow match doesnt cause any weird twisting issues.
                # if cmds.objExists(character + ":elbowswitch_"+side):
                #     print "NEW CODE WORKING"
                #     ptCnst = cmds.pointConstraint(character + ":elbowswitch_"+side, character + ":ik_elbow_" + side + "_anim")
                # else:
                #     cmds.pointConstraint("driver_lowerarm_"+side, character + ":ik_elbow_" + side + "_anim")
                # # CRA END NEW CODE
                #
                # if side == "l":
                #     cmds.setAttr(constraint + ".offsetX", 90)
                #
                # if side == "r":
                #     cmds.setAttr(constraint + ".offsetX", -90)
                #
                #
                # cmds.setKeyframe(character + ":ik_wrist_" + side + "_anim")
                # cmds.setKeyframe(character + ":ik_elbow_" + side + "_anim")
                #
                # # CRA NEW CODE
                # if cmds.objExists(character + ":elbowswitch_"+side):
                #     cmds.delete(ptCnst)
                # # CRA END NEW CODE
                #
                # cmds.delete(constraint)
                # #delete the original mode pose joints
                # cmds.delete(dupeNodes[0])


        if limb == "clav":
            #setup constraints based on mode info
            if matchTo == "IK":

                constraint1 = cmds.orientConstraint(character + ":ik_clavicle_" + side, character + ":fk_clavicle_" + side + "_anim")[0]
                cmds.setKeyframe(character + ":fk_clavicle_" + side + "_anim")
                cmds.delete(constraint1)

            if matchTo == "FK":

                constraint1 = cmds.pointConstraint(character + ":driver_upperarm_" + side, character + ":clavicle_" + side + "_anim")[0]
                cmds.setKeyframe(character + ":clavicle_" + side + "_anim")
                cmds.delete(constraint1)






        #leg matching
        attrList = cmds.listAttr(character + ":Skeleton_Settings", shortNames=True)
        for i in attrList:
            if i == "legStyle":
                legStyle = cmds.getAttr(character+":Skeleton_Settings.legStyle")

        if limb == "leg":
            dupeNodes = cmds.duplicate(character + ":" + legBones[0] + side)

            parent = cmds.listRelatives(dupeNodes[0], parent = True)
            if parent != None:
                cmds.parent(dupeNodes[0], world = True)


            #setup constraints based on mode info
            if matchTo == "IK":

                cmds.orientConstraint("thigh_" + side, character + ":fk_thigh_" + side + "_anim")
                cmds.orientConstraint("calf_" + side, character + ":fk_calf_" + side + "_anim")
                if legStyle == 1:
                    cmds.orientConstraint("heel_" + side, character + ":fk_heel_" + side + "_anim")
                cmds.orientConstraint("foot_" + side, character + ":fk_foot_" + side + "_anim")

                if cmds.objExists("ball_" + side):
                    cmds.orientConstraint("ball_" + side, character + ":fk_ball_" + side + "_anim")


                cmds.setKeyframe(character + ":fk_thigh_" + side + "_anim")
                cmds.setKeyframe(character + ":fk_calf_" + side + "_anim")
                if legStyle == 1:
                    cmds.setKeyframe(character + ":fk_heel_" + side + "_anim")
                cmds.setKeyframe(character + ":fk_foot_" + side + "_anim")
                if cmds.objExists("ball_" + side):
                    cmds.setKeyframe(character + ":fk_ball_" + side + "_anim")



            if matchTo == "FK":

                cmds.select(clear = True)
                loc1 = character + ":matchLoc_knee_1_" + side
                loc2 = character + ":matchLoc_knee_2_" + side

                #setup constraints
                for ctrl in ":heel_ctrl_" + side, ":toe_wiggle_ctrl_" + side, ":toe_tip_ctrl_" + side, ":ik_foot_anim_" + side]:
                    cmds.select(character + ctrl, add = True)

                self.resetSelection()
                cmds.setKeyframe()

                #reverse foot matching setup
                if solveRoll:
                    if cmds.objExists(character + ":fk_ball_" + side + "_anim"):
                        cmds.refresh(force = True)
                        footLoc = cmds.spaceLocator(name = character + ":matchLoc_foot_" + side)[0]
                        ikFootLoc = cmds.spaceLocator(name = character + ":matchLoc_ik_foot_" + side)[0]
                        toeLoc = cmds.spaceLocator(name = character + ":matchLoc_toe_" + side)[0]

                        cmds.parent(footLoc, character + ":fk_ball_" + side + "_anim")
                        cmds.parent(toeLoc, character + ":fk_foot_" + side + "_anim")

                        cmds.parentConstraint(character + ":fk_foot_" + side + "_anim", footLoc)
                        cmds.parentConstraint(character + ":fk_ball_" + side + "_anim", toeLoc)
                        const = cmds.parentConstraint(character + ":master_foot_ball_pivot_" + side, ikFootLoc)[0]
                        cmds.delete(const)


                        #world position locators
                        startPos = cmds.spaceLocator()[0]
                        midPos = cmds.spaceLocator()[0]
                        endPos = cmds.spaceLocator()[0]

                        cmds.parentConstraint(footLoc, startPos)
                        cmds.parentConstraint(toeLoc, midPos)
                        cmds.parentConstraint(character + ":foot_ikHandle_" + side, endPos)

                    else:
                        solveRoll = False



                if not solveRoll:
                    loc = cmds.spaceLocator(name = character + ":ik_foot_anim_" + side + "_locator")[0]
                    constraint = cmds.parentConstraint("foot_" + side, loc)[0]
                    cmds.delete(constraint)

                    cmds.pointConstraint(loc, character + ":ik_foot_anim_" + side)
                    constraint = cmds.orientConstraint(loc, character + ":ik_foot_anim_" + side)[0]

                    if side == "l":
                        cmds.setAttr(constraint + ".offsetY", 90)

                    if side == "r":
                        cmds.setAttr(constraint + ".offsetX", 180)
                        cmds.setAttr(constraint + ".offsetY", 90)

                else:
                    ikFootConst = cmds.parentConstraint(ikFootLoc, character + ":ik_foot_anim_" + side, mo = True)[0]
                    cmds.parentConstraint(toeLoc, ikFootLoc)

                    cmds.setAttr(character + ":Rig_Settings." + side + "LegMode", 1)
                    cmds.setKeyframe(character + ":Rig_Settings." + side + "LegMode")

                    #heel solve
                    self.ikHeelSolve(character, side, startPos, midPos, endPos)

                    cmds.setAttr(character + ":Rig_Settings." + side + "LegMode", 0)
                    cmds.setKeyframe(character + ":Rig_Settings." + side + "LegMode")


                cmds.setKeyframe(character + ":ik_foot_anim_" + side)



                #knee solve
                for x in range(1500):
                    angle = self.getAngleBetween(loc1, loc2)
                    if abs(angle) > .25:
                        self.ikKneeSolve(character, side, angle, loc1, loc2)
                    else:
                        break
                if not solveRoll:
                    cmds.delete(loc)

                else:
                    cmds.delete(footLoc)
                    cmds.delete(ikFootLoc)
                    cmds.delete(toeLoc)

                cmds.setKeyframe(character + ":ik_foot_anim_" + side)

            #delete the original mode pose joints
            cmds.delete(dupeNodes[0])


        #spine matching
        if limb == "spine":
            dupeNodes = cmds.duplicate(character + ":" + spineBones[0])

            parent = cmds.listRelatives(dupeNodes[0], parent = True)
            if parent != None:
                cmds.parent(dupeNodes[0], world = True)

            #setup constraints based on mode info
            # Switching to FK
            if matchTo == "IK":

                #check to see if user has any project specific match scripts (Fortnite custom)
                if cmds.objExists(character + ":spine_02_anim.driven"):
                    #furthermore, if the plusMinusAvg nodes exist, then import custom matching
                    if os.path.exists(self.mayaToolsDir + "/General/Scripts/fortniteRotoMatch.py"):

                        result = cmds.confirmDialog(title = "Match Options", icon = "question", message = "Which match option would you like to use?", button = "Standard", "Rotoscope"])

                        if result == "Standard":

                            try:
                                cmds.setAttr(character + ":spine_02_anim.driven", 0)
                                cmds.setAttr(character + ":spine_04_anim.driven", 0)
                            except:
                                pass

                            if cmds.objExists(character + ":spine_01_anim"):
                                cmds.orientConstraint("driver_spine_01", character + ":spine_01_anim")
                                cmds.setKeyframe(character + ":spine_01_anim")

                            if cmds.objExists(character + ":spine_02_anim"):
                                cmds.orientConstraint("driver_spine_02", character + ":spine_02_anim")
                                cmds.setKeyframe(character + ":spine_02_anim")

                            if cmds.objExists(character + ":spine_03_anim"):
                                cmds.orientConstraint("driver_spine_03", character + ":spine_03_anim")
                                cmds.setKeyframe(character + ":spine_03_anim")

                            if cmds.objExists(character + ":spine_04_anim"):
                                cmds.orientConstraint("driver_spine_04", character + ":spine_04_anim")
                                cmds.setKeyframe(character + ":spine_04_anim")

                            if cmds.objExists(character + ":spine_05_anim"):
                                cmds.orientConstraint("driver_spine_05", character + ":spine_05_anim")
                                cmds.setKeyframe(character + ":spine_05_anim")

                            #for each in spineBones:
                                #if cmds.objExists(character + ":" + each + "_anim"):
                                    #cmds.setKeyframe(character + ":" + each + "_anim")


                        if result == "Rotoscope":
                            import fortniteRotoMatch as fnRm
                            reload(fnRm)
                            fnRm.RotoSpineMatch(character)


                else:
                    if cmds.objExists(character + ":spine_01_anim"):
                        cmds.orientConstraint("driver_spine_01", character + ":spine_01_anim")
                        cmds.setKeyframe(character + ":spine_01_anim")

                    if cmds.objExists(character + ":spine_02_anim"):
                        cmds.orientConstraint("driver_spine_02", character + ":spine_02_anim")
                        cmds.setKeyframe(character + ":spine_02_anim")

                    if cmds.objExists(character + ":spine_03_anim"):
                        cmds.orientConstraint("driver_spine_03", character + ":spine_03_anim")
                        cmds.setKeyframe(character + ":spine_03_anim")

                    if cmds.objExists(character + ":spine_04_anim"):
                        cmds.orientConstraint("driver_spine_04", character + ":spine_04_anim")
                        cmds.setKeyframe(character + ":spine_04_anim")

                    if cmds.objExists(character + ":spine_05_anim"):
                        cmds.orientConstraint("driver_spine_05", character + ":spine_05_anim")
                        cmds.setKeyframe(character + ":spine_05_anim")

                    #for each in spineBones:
                        #if cmds.objExists(character + ":" + each + "_anim"):
                            #cmds.setKeyframe(character + ":" + each + "_anim")

            # Switching to IK
            if matchTo == "FK":

                if cmds.objExists(character + ":chest_ik_anim"):

                    #find highest spine joint
                    numSpineBones = cmds.getAttr(character + ":Skeleton_Settings.numSpineBones")
                    if numSpineBones == 5:
                        endSpine = "driver_spine_05"
                        midSpine = "driver_spine_03"]

                    if numSpineBones == 4:
                        endSpine = "driver_spine_04"
                        midSpine = "driver_spine_02", "driver_spine_03"]

                    if numSpineBones == 3:
                        endSpine = "driver_spine_03"
                        midSpine = "driver_spine_02"]

                    if cmds.objExists("chest_ik_anim_MATCH"):
                        cmds.parentConstraint("chest_ik_anim_MATCH", character + ":chest_ik_anim")
                        cmds.parentConstraint("mid_ik_anim_MATCH", character + ":mid_ik_anim")
                    else:
                        cmds.parentConstraint(endSpine, character + ":chest_ik_anim")
                        for each in midSpine:
                            cmds.parentConstraint(each, character + ":mid_ik_anim")

                cmds.setKeyframe([character + ":chest_ik_anim", character + ":mid_ik_anim"])


            #delete the original mode pose joints
            cmds.delete(dupeNodes[0])


        #reselect selection before entering process
        if len(currentSelection) > 0:
            cmds.select(currentSelection)


        if autoKeyOn:
            cmds.autoKeyframe(state = True)

in ART_autorigger.py:

class AutoRigger():

    def __init__(self, handCtrlSpace, progressBar):


        self.handCtrlSpace = handCtrlSpace

        #get access to our maya tools
        toolsPath = cmds.internalVar(usd = True) + "mayaTools.txt"
        if os.path.exists(toolsPath):

            f = open(toolsPath, 'r')
            self.mayaToolsDir = f.readline()
            f.close()


        #create a progress window to track the progress of the rig build
        self.progress = 0
        cmds.progressBar(progressBar, edit = True, progress=self.progress, status='Creating Spine Rig')



        #build the core of the rig
        import Modules.ART_Core
        coreNodes = Modules.ART_Core.RigCore()
        
        cmds.select("Rig_Settings",r=True)
        cmds.addAttr(ln="scaleFactor",at="float", keyable = False)
        cmds.setAttr("Rig_Settings."+"scaleFactor",utils.getScaleFactor(),lock=True)
        cmds.select(cl=True)
        #BODY CONTROL
        self.buildHips()

        """
        #create the rig settings node
        "Rig_Settings" = cmds.group(empty = True, name = "Rig_Settings")
        cmds.setAttr("Rig_Settings" + ".tx", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".ty", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".tz", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".rx", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".ry", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".rz", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".sx", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".sy", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".sz", lock = True, keyable = False)
        cmds.setAttr("Rig_Settings" + ".v", lock = True, keyable = False)


        #build the spine rigs
        self.createDriverSkeleton()
        self.buildCoreComponents()
        """

        #to be replaced by modules
        fkControls = self.buildFKSpine()
        ikControls = self.buildIKSpine(fkControls)


        #build the leg rigs

        #first determine the leg style
        legStyle = cmds.getAttr("SkeletonSettings_Cache.legStyle")

        if legStyle == "Standard Biped":
            cmds.progressBar(progressBar, edit = True, progress = 20, status='Creating Leg Rigs')
            self.buildFKLegs()
            self.buildIKLegs()
            self.finishLegs()


            cmds.progressBar(progressBar, edit = True, progress = 30, status='Creating Toe Rigs')
            self.buildToes()
            cmds.progressBar(progressBar, edit = True, progress = 40, status='Creating Auto Hips and Spine')
            self.buildAutoHips()
            self.autoSpine()

        if legStyle == "Hind Leg":
            cmds.progressBar(progressBar, edit = True, progress = 20, status='Creating Leg Rigs')
            self.buildFKLegs_hind()
            self.buildIKLegs_hind()
            self.finishLegs_hind()


            cmds.progressBar(progressBar, edit = True, progress = 30, status='Creating Toe Rigs')
            self.buildToes()
            cmds.progressBar(progressBar, edit = True, progress = 40, status='Creating Auto Hips and Spine')
            self.buildAutoHips()
            self.autoSpine()



        #build the arms
        cmds.progressBar(progressBar, edit = True, progress = 50, status='Creating Arm Rigs')
        spineBones = self.getSpineJoints()
        lastSpine = "driver_" + spineBones-1]
        print lastSpine
        import Modules.ART_Arm
        reload(Modules.ART_Arm)
        Modules.ART_Arm.Arm(True, "", None, "l", lastSpine, 6, True)
        Modules.ART_Arm.Arm(True, "", None, "r", lastSpine, 13, True)


        """
        self.buildFKArms()
        self.buildIkArms()
        """

        cmds.progressBar(progressBar, edit = True, progress = 60, status='Creating Finger Rigs')
        self.buildFingers()

        #build the neck and head rig
        cmds.progressBar(progressBar, edit = True, progress = 70, status='Creating Neck and Head Rigs')
        self.buildNeckAndHead()


        #rig extra joints
        cmds.progressBar(progressBar, edit = True, progress = 80, status='Creating Rigs for Custom Joints')
        createdControls = self.rigLeafJoints()
        createdJiggleNodes = self.rigJiggleJoints()
        createdChainNodes = self.rigCustomJointChains()





        #clean up the hierarchy
        cmds.progressBar(progressBar, edit = True, progress = 90, status='Cleaning up Scene')

        bodyGrp = cmds.group(empty = True, name = "body_grp")
        for obj in "spine_splineIK_curve", "splineIK_spine_01_splineIK", "body_anim_space_switcher_follow"]:
            if cmds.objExists(obj):
                cmds.parent(obj, bodyGrp)

        if cmds.objExists("autoHips_sys_grp"):
            cmds.parent("autoHips_sys_grp", "body_anim")


        rigGrp = "ctrl_rig"
        cmds.parent([bodyGrp, "leg_sys_grp"], rigGrp)

        """
        rigGrp = cmds.group(empty = True, name = "ctrl_rig")
        cmds.parent([bodyGrp, "leg_sys_grp", "Rig_Settings"], rigGrp)
	cmds.parent(rigGrp, "offset_anim")
	"""


        #Arms
        """
        if cmds.objExists("arm_rig_master_grp_l"):
            cmds.setAttr("Rig_Settings.lArmMode", 1)

	    if cmds.objExists("lowerarm_l_roll_grp"):
		cmds.parent("lowerarm_l_roll_grp", "arm_rig_master_grp_l")

            cmds.parent("arm_rig_master_grp_l", "ctrl_rig")


        if cmds.objExists("arm_rig_master_grp_r"):
            cmds.setAttr("Rig_Settings.rArmMode", 1)

	    if cmds.objExists("lowerarm_r_roll_grp"):
		cmds.parent("lowerarm_r_roll_grp", "arm_rig_master_grp_r")

            cmds.parent("arm_rig_master_grp_r", "ctrl_rig")

        if cmds.objExists("arm_rig_master_grp_r") and cmds.objExists("arm_rig_master_grp_l"):
            armSysGrp = cmds.group(empty = True, name = "arm_sys_grp")
            cmds.parent(armSysGrp, "ctrl_rig")
            cmds.parent("arm_rig_master_grp_r", "arm_rig_master_grp_l", "ik_wrist_l_anim_space_switcher_follow", "ik_wrist_r_anim_space_switcher_follow"], armSysGrp)

	    #arm twists
	    if cmds.objExists("upperarm_twist_grp_l"):
		cmds.parent("upperarm_twist_grp_l", armSysGrp)

	    if cmds.objExists("upperarm_twist_grp_r"):
		cmds.parent("upperarm_twist_grp_r", armSysGrp)
	"""


        if cmds.objExists("neck_01_fk_anim_grp"):
            cmds.parent("neck_01_fk_anim_grp", "ctrl_rig")

        #Fingers
        if cmds.objExists("finger_sys_grp_l"):
            cmds.parent("finger_sys_grp_l", "ctrl_rig")

        if cmds.objExists("finger_sys_grp_r"):
            cmds.parent("finger_sys_grp_r", "ctrl_rig")


        #Custom Joints (leaf, jiggle, chain)
        if len(createdControls) > 0:
            for each in createdControls:
                cmds.parent(each, "ctrl_rig")

        if len(createdJiggleNodes) > 0:
            for each in createdJiggleNodes:
                cmds.parent(each, "ctrl_rig")

        if len(createdChainNodes) > 0:
            for each in createdChainNodes:
                cmds.parent(each, "ctrl_rig")

        cmds.parent("head_sys_grp", "ctrl_rig")

        #finish grouping everything under 1 character grp
        if cmds.objExists("Proxy_Geo_Skin_Grp"):
            try:
                cmds.parent("Proxy_Geo_Skin_Grp", "rig_grp")
            except:
                pass

        if cmds.objExists("dynHairChain"):
            try:
                cmds.parent("dynHairChain", "rig_grp")
            except:
                pass


        #add world spaces to each space switch control
        self.addSpaces()

        #Hide all joints
        joints = cmds.ls(type = 'joint')
        for joint in joints:
            if cmds.getAttr(joint + ".v", settable = True):
                cmds.setAttr(joint + ".v", 0)
        cmds.progressBar(progressBar, edit = True, progress = 100, status='Cleaning up Scene')

        #delete the joint mover
        cmds.select("root_mover_grp", r = True, hi = True)
        cmds.select("Skeleton_Settings", add = True)
        nodes = cmds.ls(sl = True, transforms = True)
        cmds.select(clear = True)

        for node in nodes:
            cmds.lockNode(node, lock = False)
        cmds.lockNode("JointMover", lock = False)
        cmds.delete("JointMover")

        #find and delete junk nodes/clean scene
        for obj in "invis_legs_Rig_Settings", "invis_legs_Rig_Settings1", "invis_legs_spine_splineIK_curve", "invis_legs_spine_splineIK_curve1","invis_legs_master_anim_space_switcher_follow", "invis_legs_master_anim_space_switcher_follow1"]:
            try:
                cmds.select("*" + obj + "*")
                selection = cmds.ls(sl = True)
                for each in selection:
                    if cmds.objExists(each):
                        cmds.delete(each)
            except:
                pass


        cmds.select(all = True)
        selection = cmds.ls(sl = True)

        for each in selection:
            if each.find("invis_") == 0:

                try:
                    parent = cmds.listRelatives(each, parent = True)
                    if parent == None:
                        cmds.delete(each)
                except:
                    pass

        #New IK KNEE MATCHING STUFF!
        loc1 = cmds.spaceLocator(name = "matchLoc_knee_1_l")
        loc2 = cmds.spaceLocator(name = "matchLoc_knee_2_l")

        constraint = cmds.pointConstraint("fk_calf_l_anim", loc1)[0]
        cmds.delete(constraint)
        cmds.parent(loc1, "fk_calf_l_anim")

        constraint = cmds.pointConstraint("ik_leg_calf_l", loc2)[0]
        cmds.delete(constraint)
        cmds.parent(loc2, "ik_leg_calf_l")

        cmds.select(loc1)
        cmds.move(0, -30, 0, r = True)

        cmds.select(loc2)
        cmds.move(0, -30, 0, r = True)
        cmds.setAttr(loc1[0] + ".v", 0)
        cmds.setAttr(loc2[0] + ".v", 0)




        loc1 = cmds.spaceLocator(name = "matchLoc_knee_1_r")
        loc2 = cmds.spaceLocator(name = "matchLoc_knee_2_r")

        constraint = cmds.pointConstraint("fk_calf_r_anim", loc1)[0]
        cmds.delete(constraint)
        cmds.parent(loc1, "fk_calf_r_anim")

        constraint = cmds.pointConstraint("ik_leg_calf_r", loc2)[0]
        cmds.delete(constraint)
        cmds.parent(loc2, "ik_leg_calf_r")

        cmds.select(loc1)
        cmds.move(0, -30, 0, r = True)

        cmds.select(loc2)
        cmds.move(0, -30, 0, r = True)
        cmds.setAttr(loc1[0] + ".v", 0)
        cmds.setAttr(loc2[0] + ".v", 0)




        #set default rotate Orders
        self.setDefaultRotateOrders()

        #end progress window
        cmds.select(clear = True)

Hey Lion, thanks so much for the contribution. A couple things, is this suppose to add the “matching…” menu option in the right click in the animation UI, similar to the arms and legs? Also, is this code current with the current marketplace download? If so, I’ll go ahead and do some tests with it and check the diff between our current code to make sure nothing else breaks, if so, I’ll definitely add it.

[AaronCarlisle]

@lion032;646893

There is a bug in the motion import class that causes the an incorrect project path to be stored if there is a reference with “Project” in it’s path but not in the ART project path.
This causes the import motion class not being able to read the saved animation.

Solution:

class ImportMotionUI():

    def __init__(self, uiInst):

        #create class variables
        self.widgets = {}
        self.selection = cmds.ls(sl = True)
        self.uiInst = uiInst

        #get access to our maya tools
        toolsPath = cmds.internalVar(usd = True) + "mayaTools.txt"
        if os.path.exists(toolsPath):

            f = open(toolsPath, 'r')
            self.mayaToolsDir = f.readline()
            f.close()
            
            
        #find out which project we are in
        references = cmds.ls(type = "reference")
        for ref in references:
            try:
                query = cmds.referenceQuery(ref, filename = True)
                #check if the reference is in the ART project path
                if query.find(self.mayaToolsDir) != -1:  
                    self.project = query.rpartition("Projects/")[2].partition("/")[0]

            except:
                pass

Awesome, thanks Lion32, added, expect it to be in the next Marketplace release.

[AaronCarlisle]

@davidhammertime;654712

Hi guys,

I’m using A.R.T.1.0 from the marketplace for the first time, Maya 2017 and Engine v4.14. I’m just building the rig with default values, and getting the following error:

Any idea how to fix? I didn’t see an answer in this thread yet. Also, when I run the Character Rig Creator, a few pieces of the proxy character meshes have a display issue, the entire right arm and the right thigh…

Any help would be greatly appreciated!

Hey davidhammertime, it looks like you’re still using the code from Dropbox, not the code from the marketplace. If you go to A.R.T.1.0 menu and click “Settings” you can change the location of the “Tools Path” to point to the MayaTools folder you downloaded from the Marketplace. I think this will fix your issue.

[AaronCarlisle]

@Rodaelli;674224

Hello , i want to know if i can import fbx animation from mixamo and use it. I tried and I faced some problems. It was distorting my char like in the img. I tried to use the same bone as mixamo uses and I got that. Someone cold help me? Is there is any possibilites to import animation from mixamo and apply in my character in ART plugin ? Thanks alot!!!

Hello Rodaelli, I’m not that familiar with mixamo, but if the bones of the animations from that tool don’t match the names of the bones in ART, the fbx will not import correctly. You can retarget them in the engine and pipe that out so that the joints match, but I’m not quite sure on your experience with that; definitely doable though.

[AaronCarlisle]

@Jakobo48;682434

ART_skeletonBuilder_UI.py line 11741: invalid literal for int() with base 10: ‘Nothing counted : no polygonal object is selected.’ #

I’m getting the above error anytime I try to return to Skeleton Placement from the Deformation Setup step. It doesn’t matter if any object is selected or not. I’m using Maya 2016 and the A.R.T. from the Unreal Marketplace. I’ve also updated with the files from Dropbox and get the same result. Any thoughts?

Additional Info/Solution Edit:

It appears to be trying to save out weight data for a mover (in this case hair), crashes, and creates a 0KB file with the wrong naming convention in the system folder. If I delete that I can at least start from scratch and load whatever weights it wrote out before hitting that point.

It looks like that mover got caught up in my wild card for binding, so wild card unbinding the movers in the scene got everything working again. Modified my code to specify joints in the Skeleton hierarchy hehe.

I do believe I fixed this bug awhile ago (or at least someone did). There should be an update to the marketplace with a few updates, I’m guessing this will be one of them. After the next update, if you’re still having the issue, PM me and I’ll fix it.

[AaronCarlisle]

Just wanted to do a quick update for everyone. Currently ART V2 is being used internally (mostly BETA). It’s for the most part up to par with the current version of ART V1 minus some animation tools (which is currently working on) and of course, it’s modular, so having more dynamic characters (like characters with four arms, three heads, ten legs… etc) will be available. As for a release cadence, I still haven’t decided, but I will be doing an update fairly soon. added some new IK/FK matching that works a lot better than what’s currently in place (fixes a lot of popping/twisting and offsetting when you’re away from the origin).

Please continue to post your issues and concerns (or even contributions like lion) and I’ll try to get back to them when I can (sometimes it just get’s pretty busy and I lag behind a little, but I’ll do my best to keep current).

Best,
-Aaron

[anonymous_user_99204cf2]

Hello Everyone.

Quick question. I am working in a project that requires the characters to be facing “x positive” rather than “y negative”. Having Z UP is fine by us. Is any way to change this inside ART? Or is just better to export the animations\skeleton rotating the root manually?

Thanks

[anonymous_user_7d8324b51 (anonymous_user_7d8324b5)]

@lacedoportalesff;683628

Hello Everyone.

Quick question. I am working in a project that requires the characters to be facing “x positive” rather than “y negative”. Having Z UP is fine by us. Is any way to change this inside ART? Or is just better to export the animations\skeleton rotating the root manually?

Thanks

We’re facing the same problem. There’s an option to Force Front XAxis" in the import window of UE4, but I still need to test it. As for Maya, my assumption is that it would require quite a lot of work to adapt the whole system to us positive X, but let’s wait for a response from Aaron. For the moment im exploring the possibity to convert it between the export and import phases of Maya and UE4

[AaronCarlisle]

@lacedoportalesff;683628

Hello Everyone.

Quick question. I am working in a project that requires the characters to be facing “x positive” rather than “y negative”. Having Z UP is fine by us. Is any way to change this inside ART? Or is just better to export the animations\skeleton rotating the root manually?

Thanks

It sounds like you just need to position your joint movers in the correct position. You’re not changing the Z up functionality, you’re just wanting to face in a different direction. You could just take the root joint mover in the joint position setup and rotate it in the correct position? Would that work?

Another option, if that doesn’t work, is to use a post script at build time and in the post script, simply rotate the root control in the 90 degrees or 180 degrees as you please. You’d have rotation values, but it might not be the worst option depending on what you’re doing. Is this an Unreal project or are you working outside of Unreal for this?

[Comatos]

[FONT=&quot]Question: I just want to build my rig with no legs, since my creature has no legs. Is it possible to leave the legs out or go in after creation and remove them before I send the model to weight painting and control rig creation? I am using the art tool and I had a similar problem last week where I needed only 2 spine bones(3 being minimum). So I only weighted to those two bones and just didnt weight the third. This worked fine for just one extra bone thats unused. But doing this with 2 entire leg chains seems like alot. Is there a way to overide the creation of the leg chain entirely?

[AerysBat]

@Aaron.Carlisle;683261

Currently ART V2 is being used internally (mostly BETA).

I’m very excited for this!

[lion032 (Leon Rosengarten)]

@Aaron.Carlisle;683245

Hey Lion, thanks so much for the contribution. A couple things, is this suppose to add the “matching…” menu option in the right click in the animation UI, similar to the arms and legs? Also, is this code current with the current marketplace download? If so, I’ll go ahead and do some tests with it and check the diff between our current code to make sure nothing else breaks, if so, I’ll definitely add it.

1. Yes, it adds fk/ik matching option similar to arms and legs for the fingers.
2. As far as I remember I branched off the marketplace version.