pyjallib 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

pyjallib/__init__.py

@@ -6,7 +6,7 @@ pyjallib Package
 Python library for game character development pipeline.
 """
 
-__version__ = '0.1.11'
+__version__ = '0.1.13'
 
 # reload_modules 함수를 패키지 레벨에서 사용 가능하게 함
 from pyjallib.namePart import NamePart, NamePartType

pyjallib/max/__init__.py

@@ -35,6 +35,11 @@ from pyjallib.max.volumeBone import VolumeBone
 from pyjallib.max.kneeBone import KneeBone
 from pyjallib.max.hip import Hip
 
+from pyjallib.max.rootMotion import RootMotion
+
+from pyjallib.max.fbxHandler import FBXHandler
+from pyjallib.max.toolManager import ToolManager
+
 from pyjallib.max.ui.Container import Container
 
 # 모듈 내보내기
@@ -55,14 +60,13 @@ __all__ = [
     'Morph',
     'BoneChain',
     'TwistBone',
-    'TwistBoneChain',
     'GroinBone',
-    'GroinBoneChain',
     'AutoClavicle',
-    'AutoClavicleChain',
     'VolumeBone',
-    'VolumeBoneChain',
     'KneeBone',
     'Hip',
+    'RootMotion',
+    'FBXHandler',
+    'ToolManager',
     'Container'
 ]

pyjallib/max/anim.py

@@ -477,6 +477,40 @@ class Anim:
         """
         rt.deleteKeys(inObj, rt.Name('allKeys'))
     
+    def delete_keys_in_range(self, node, startFrame, endFrame):
+        """
+        지정된 프레임 범위에서 노드의 모든 키를 삭제하는 함수
+        
+        Args:
+            node: 키를 삭제할 노드
+            startFrame (int): 시작 프레임
+            endFrame (int): 끝 프레임
+        
+        Returns:
+            bool: 성공 여부
+        """
+        if not rt.isValidNode(node):
+            return False
+        
+        try:
+            maxscriptCode = f"""
+            (
+                selectKeys $'{node.name}'.position.controller (interval {startFrame} {endFrame})
+                deleteKeys $'{node.name}'.position.controller #selection
+                
+                selectKeys $'{node.name}'.rotation.controller (interval {startFrame} {endFrame})
+                deleteKeys $'{node.name}'.rotation.controller #selection
+                
+                selectKeys $'{node.name}'.scale.controller (interval {startFrame} {endFrame})
+                deleteKeys $'{node.name}'.scale.controller #selection
+            )
+            """
+            rt.execute(maxscriptCode)
+            return True
+        except Exception as e:
+            print(f"Error deleting keys in range: {e}")
+            return False
+    
     def is_node_animated(self, node):
         """
         객체 및 그 하위 요소(애니메이션, 커스텀 속성 등)가 애니메이션 되었는지 재귀적으로 확인함.
@@ -574,6 +608,56 @@ class Anim:
         
         return result
     
+    def save_animation(self, inObjs, inSaveFilePath):
+        """
+        객체의 애니메이션을 저장함.
+        
+        매개변수:
+            inObj : 애니메이션을 저장할 객체
+        """
+        
+        if not(len(inObjs) > 0):
+            return False
+        
+        for obj in inObjs:
+            if not(rt.isValidNode(obj)):
+                return False
+        
+        animatedNodes = self.find_animated_nodes(inObjs)
+        rt.LoadSaveAnimation.setUpAnimsForSave(animatedNodes, animatedTracks=True, includeContraints=True, keyable=True)
+        rt.LoadSaveAnimation.saveAnimation(
+            inSaveFilePath,
+            animatedNodes,
+            "tempVal",
+            "tempVal",
+            animatedTracks=True,
+            includeConstraints=True,
+            keyableTracks=False,
+            SaveSegment=True,
+            segInterval=rt.animationRange,
+            segKeyPerFrame=True
+        )
+        
+        return True
+    
+    def load_animation(self, inObjs, inLoadFilePath):
+        """
+        애니메이션을 로드함.
+        
+        매개변수:
+            inObjs : 애니메이션을 로드할 객체
+            inLoadFilePath : 애니메이션을 로드할 파일 경로
+        """
+        
+        if not(rt.doesFileExist(inLoadFilePath)):
+            return False
+        
+        rt.LoadSaveAnimation.setUpAnimsForLoad(inObjs, includePB2s=True, stripLayers=True)
+        rt.LoadSaveAnimation.loadAnimation(inLoadFilePath, inObjs, insert=False, relative=False, insertTime=0, stripLayers=True)
+        
+        return True
+        
+    
     def save_xform(self, inObj):
         """
         객체의 현재 변환 행렬(월드, 부모 스페이스)을 저장하여 복원을 가능하게 함.

pyjallib/max/autoClavicle.py

@@ -108,7 +108,7 @@ class AutoClavicle:
         autoClavicleBone.transform = inClavicle.transform
         self.anim.move_local(autoClavicleBone, clavicleLength/2.0, 0.0, 0.0)
         autoClavicleBone.parent = inClavicle
-        genBones.extend(autoClavicleBone)
+        genBones.append(autoClavicleBone)
         
         # 타겟 헬퍼 포인트 생성 (쇄골과 상완용)
         rotTargetClavicle = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Target")))

pyjallib/max/bip.py

@@ -439,80 +439,166 @@ class Bip:
             if colNum > 0:
                 rt.biped.deleteAllCopyCollections(inBipRoot.controller)
     
-    def link_base_skeleton(self, skinBoneBaseName="b"):
-        """
-        기본 스켈레톤 링크 (Biped와 일반 뼈대 연결)
+    def collapse_layers(self, inBipRoot):
         """
-        rt.setWaitCursor()
+        Biped 레이어 병합
         
-        bipSkel = self.get_bips()
-        baseSkel = [None] * len(bipSkel)
+        Args:
+            inBipRoot: 대상 Biped 객체
+        """
+        if not self.is_biped_object(inBipRoot):
+            return False
         
-        for i in range(len(bipSkel)):
-            baseSkeletonName = self.name.replace_base(bipSkel[i].name, skinBoneBaseName)
-            baseSkeletonName = self.name.replace_filteringChar(baseSkeletonName, "_")
-            baseSkelObj = rt.getNodeByName(baseSkeletonName)
-            if rt.isValidObj(baseSkelObj):
-                baseSkel[i] = baseSkelObj
+        layerNum = rt.biped.numLayers(inBipRoot.controller)
+        while layerNum > 0:
+            rt.biped.collapseAtLayer(inBipRoot.controller, 0)
+            layerNum = rt.biped.numLayers(inBipRoot.controller)
+    
+    def save_bip_file(self, inBipRoot, inFile, inBakeAllKeys=True, inCollapseLayers=True, inUseAnimationRangeOnly=True, progress_callback=None):
+        """
+        Biped BIP 파일 저장
         
-            self.anim.save_xform(bipSkel[i])
-            self.anim.set_xform(bipSkel[i])
+        Args:
+            inBipRoot: 저장 대상 Biped 루트 노드
+            inFile: 저장할 BIP 파일 경로
+            inBakeAllKeys: 모든 키를 베이크할지 여부 (기본값: True)
+            inCollapseLayers: 레이어를 병합할지 여부 (기본값: True)
             
-            self.anim.save_xform(baseSkel[i])
-            self.anim.set_xform(baseSkel[i])
+        Returns:
+            bool: 저장 성공 시 True, 실패 시 False
+        """
+        if not self.is_biped_object(inBipRoot):
+            return False
         
-        for i in range(len(baseSkel)):
-            if baseSkel[i] is not None:
-                baseSkel[i].scale.controller = rt.scaleXYZ()
-                baseSkel[i].controller = rt.link_constraint()
+        directory = os.path.dirname(inFile)
+        if directory and not os.path.exists(directory):
+            try:
+                os.makedirs(directory, exist_ok=True)
+            except OSError as e:
+                return False
+        
+        if inCollapseLayers:
+            self.collapse_layers(inBipRoot)
+        
+        if inBakeAllKeys:
+            allTargetBipedObjs = self.get_nodes(inBipRoot)
+            startFrame = rt.execute("(animationRange.start as integer) / TicksPerFrame")
+            endFrame = rt.execute("(animationRange.end as integer) / TicksPerFrame")
+            totalFrame = endFrame - startFrame + 1
+            
+            for frame in range(startFrame, endFrame + 1):
+                for item in allTargetBipedObjs:
+                    if item == item.controller.rootNode:
+                        horizontalController = rt.getPropertyController(item.controller, "horizontal")
+                        verticalController = rt.getPropertyController(item.controller, "vertical")
+                        turningController = rt.getPropertyController(item.controller, "turning")
+                        
+                        rt.biped.addNewKey(horizontalController, frame)
+                        rt.biped.addNewKey(verticalController, frame)
+                        rt.biped.addNewKey(turningController, frame)
+                    else:
+                        rt.biped.addNewKey(item.controller, frame)
+                if progress_callback:
+                    progress_callback(frame - startFrame + 1, totalFrame)
+                    
+        minFrame = 0.0
+        maxFrame = 0.0
+        allTargetBipedObjs = self.get_nodes(inBipRoot)
+        for item in allTargetBipedObjs:
+            if item == item.controller.rootNode:
+                horizontalController = rt.getPropertyController(item.controller, "horizontal")
+                verticalController = rt.getPropertyController(item.controller, "vertical")
+                turningController = rt.getPropertyController(item.controller, "turning")
                 
-                self.anim.set_xform([baseSkel[i]], space="World")
-                baseSkel[i].transform.controller.AddTarget(bipSkel[i], 0)
-        
-        for i in range(len(baseSkel)):
-            if baseSkel[i] is not None:
-                baseSkel[i].boneEnable = True
+                minFrame = min(float(horizontalController.keys[0].time), minFrame)
+                minFrame = min(float(verticalController.keys[0].time), minFrame)
+                minFrame = min(float(turningController.keys[0].time), minFrame)
                 
-        rt.setArrowCursor()
+                maxFrame = max(float(horizontalController.keys[-1].time), maxFrame)
+                maxFrame = max(float(verticalController.keys[-1].time), maxFrame)
+                maxFrame = max(float(turningController.keys[-1].time), maxFrame)
+            else:
+                minFrame = min(float(item.controller.keys[0].time), minFrame)
+                maxFrame = max(float(item.controller.keys[-1].time), maxFrame)
+        
+        bakeStartFrame = minFrame
+        bakeEndFrame = maxFrame
+        
+        if inUseAnimationRangeOnly:
+            allTargetBipedObjs = self.get_nodes(inBipRoot)
+            startFrame = rt.execute("(animationRange.start as integer) / TicksPerFrame")
+            endFrame = rt.execute("(animationRange.end as integer) / TicksPerFrame")
+            bakeStartFrame = startFrame
+            bakeEndFrame = endFrame
+        
+        if inBakeAllKeys:
+            rt.biped.saveBipFileSegment(inBipRoot.controller, inFile, bakeStartFrame, bakeEndFrame, rt.name("keyPerFrame"))
+        else:
+            rt.biped.saveBipFileSegment(inBipRoot.controller, inFile, bakeStartFrame, bakeEndFrame)
+        
+        return True
+    
+    def link_base_skeleton(self, skinBoneBaseName="b"):
+        """
+        기본 스켈레톤 링크 (Biped와 일반 뼈대 연결)
+        """
+        bipComs = self.get_coms()
+        if len(bipComs) != 1:
+            return False
+        
+        bipCom = bipComs[0]
+        bipNodes = self.get_nodes(bipCom)
+        
+        targetBones = [item for item in bipNodes 
+                      if (rt.classOf(item) == rt.Biped_Object) 
+                      and (not rt.matchPattern(item.name, pattern="*Twist*")) 
+                      and (item != item.controller.rootNode)]
+        sortedBipBones = self.bone.sort_bones_as_hierarchy(targetBones)
+        
+        skinBones = []
+        for item in sortedBipBones:
+            skinBoneName = self.name.replace_name_part("Base", item.name, skinBoneBaseName)
+            skinBoneName = self.name.replace_filtering_char(skinBoneName, "_")
+            foundSkinBone = rt.getNodeByName(skinBoneName)
+            if rt.isValidObj(foundSkinBone):
+                skinBones.append(foundSkinBone)
+            else:
+                skinBones.append(None)
+        
+        for i, item in enumerate(sortedBipBones):
+            if skinBones[i] is not None:
+                self.bone.link_skin_bone(skinBones[i], item)
     
     def unlink_base_skeleton(self, skinBoneBaseName="b"):
         """
         기본 스켈레톤 링크 해제
         """
-        rt.setWaitCursor()
-        
         bipComs = self.get_coms()
-        allBips = self.get_nodes(bipComs[0])
-        bipSkel = [item for item in allBips if item != bipComs[0]]
-        baseSkel = [None] * len(bipSkel)
-        
-        for i in range(len(bipSkel)):
-            baseSkeletonName = self.name.replace_name_part("Base", bipSkel[i].name, skinBoneBaseName)
-            baseSkeletonName = self.name.replace_filtering_char(baseSkeletonName, "_")
-            print("baseSkeletonName", baseSkeletonName)
-            baseSkelObj = rt.getNodeByName(baseSkeletonName)
-            print("baseSkelObj", baseSkelObj)
-            if rt.isValidObj(baseSkelObj):
-                baseSkel[i] = baseSkelObj
-        
-            self.anim.save_xform(bipSkel[i])
-            self.anim.set_xform(bipSkel[i])
-            
-            self.anim.save_xform(baseSkel[i])
-            self.anim.set_xform(baseSkel[i])
-        
-        for i in range(len(baseSkel)):
-            if baseSkel[i] is not None:
-                baseSkel[i].controller = rt.prs()
-                self.anim.set_xform([baseSkel[i]], space="World")
-        
-        for i in range(len(baseSkel)):
-            if baseSkel[i] is not None:
-                baseSkel[i].boneEnable = True
-                
-        rt.setArrowCursor()
+        if len(bipComs) != 1:
+            return False
+        
+        bipCom = bipComs[0]
+        bipNodes = self.get_nodes(bipCom)
+        targetBones = [item for item in bipNodes 
+                      if (rt.classOf(item) == rt.Biped_Object) 
+                      and (not rt.matchPattern(item.name, pattern="*Twist*")) 
+                      and (item != item.controller.rootNode)]
+        sortedBipBones = self.bone.sort_bones_as_hierarchy(targetBones)
+        skinBones = []
+        for item in sortedBipBones:
+            skinBoneName = self.name.replace_name_part("Base", item.name, skinBoneBaseName)
+            skinBoneName = self.name.replace_filtering_char(skinBoneName, "_")
+            foundSkinBone = rt.getNodeByName(skinBoneName)
+            if rt.isValidObj(foundSkinBone):
+                skinBones.append(foundSkinBone)
+            else:
+                skinBones.append(None)
+        
+        for item in skinBones:
+            if item is not None:
+                self.bone.unlink_skin_bone(item)
         
-    def convert_name_for_ue5(self, inBipRoot, inBipNameConfigFile):
+    def convert_name_for_ue5(self, inBipRoot, inBipNameConfigFile, inRenameFingers=True):
         """
         Biped 이름을 UE5에 맞게 변환
         
@@ -522,17 +608,11 @@ class Bip:
         Returns:
             변환된 Biped 객체
         """
-        bipComs = self.get_coms()
-    
-        if len(bipComs) > 1:
-            rt.messageBox("Please select only one Biped object.")
-            return False
-        
         from pyjallib.max.name import Name
         
         bipNameTool = Name(configPath=inBipNameConfigFile)
         
-        bipObj = bipComs[0]
+        bipObj = inBipRoot
         bipNodes = self.get_all(bipObj)
         for bipNode in bipNodes:
             if bipNode.name == bipObj.controller.rootName:
@@ -563,7 +643,7 @@ class Bip:
             if newNameDict["RealName"] == "Forearm":
                 newNameDict["RealName"] = "Lowerarm"
             
-            if newNameDict["RealName"] == "Spine" or newNameDict["RealName"] == "Neck":
+            if newNameDict["RealName"] == "Spine" or newNameDict["RealName"] == "Neck" or newNameDict["RealName"] == "Tail":
                 if newNameDict["Index"] == "":
                     newNameDict["Index"] = str(int(1)).zfill(self.name.get_padding_num())
                 else:
@@ -574,13 +654,6 @@ class Bip:
             bipNode.name = newBipName.lower()
             
         # 손가락 바꾸는 부분
-        # 5개가 아닌 손가락은 지원하지 않음
-        # 손가락 하나의 최대 링크는 3개
-        indices = []
-        if bipObj.controller.knuckles:
-            pass
-        else:
-            indices = list(range(0, 15, 3))
             
         fingerNum = bipObj.controller.fingers
         fingerLinkNum = bipObj.controller.fingerLinks
@@ -603,7 +676,9 @@ class Bip:
                 fingers.append(fingerNode)
             rFingersList.append(fingers)
             
-        fingerName = ["thumb", "index", "middle", "ring", "pinky"]
+        fingerName = ["finger0", "finger1", "finger2", "finger3", "finger4"]
+        if inRenameFingers:
+            fingerName = ["thumb", "index", "middle", "ring", "pinky"]
         
         for i, fingers in enumerate(lFingersList):
             for j, item in enumerate(fingers):
@@ -690,8 +765,8 @@ class Bip:
             toeNub.name = self.name.replace_name_part("Nub", toeNub.name, self.name.get_name_part_value_by_description("Nub", "Nub"))
             
             if toeLinkNum == 1:
-                rToesList[0][0].name = self.name.replace_name_part("RealName", lToesList[0][0].name, "ball")
-                rToesList[0][0].name = self.name.remove_name_part("Index", lToesList[0][0].name)
+                rToesList[0][0].name = self.name.replace_name_part("RealName", rToesList[0][0].name, "ball")
+                rToesList[0][0].name = self.name.remove_name_part("Index", rToesList[0][0].name)
             else:
                 for i, item in enumerate(rToesList[0]):
                     item.name = self.name.replace_name_part("RealName", item.name, "ball")

pyjallib/max/bone.py

@@ -212,14 +212,14 @@ class Bone:
                 return False
         return False
     
-    def create_nub_bone(self, inName, inSize):
+    def create_nub_bone(self, inName, inSize, inBoneScaleType=rt.Name("none")):
         """
         Nub 뼈대 생성.
         
         Args:
             inName: 뼈대 이름
             inSize: 뼈대 크기
-            
+            inBoneScaleType: 뼈대 스케일 타입 (기본값: rt.Name("none"))
         Returns:
             생성된 Nub 뼈대
         """
@@ -242,6 +242,8 @@ class Bone:
         nubBone.name = self.name.remove_name_part("Nub", nubBone.name)
         nubBone.name = self.name.replace_name_part("Nub", nubBone.name, self.name.get_name_part_value_by_description("Nub", "Nub"))
         
+        nubBone.boneScaleType = inBoneScaleType
+        
         # 화면 갱신 재개
         rt.enableSceneRedraw()
         rt.redrawViews()
@@ -751,6 +753,34 @@ class Bone:
         
         return True
     
+    def unlink_skin_bone(self, inSkinBone):
+        """
+        스킨 뼈대를 원본 뼈대에서 연결 해제.
+        
+        Args:
+            inSkinBone: 연결 해제할 스킨 뼈대
+        """
+        self.anim.save_xform(inSkinBone)
+        self.anim.set_xform(inSkinBone)
+        
+        inSkinBone.controller = rt.prs()
+        self.anim.set_xform(inSkinBone, space="World")
+        
+        return True
+    
+    def unlink_skin_bones(self, inSkinBoneArray):
+        """
+        스킨 뼈대 배열을 원본 뼈대에서 연결 해제.
+        
+        Args:
+            inSkinBoneArray: 연결 해제할 스킨 뼈대 배열
+        """
+        for item in inSkinBoneArray:
+            if rt.isValidObj(item):
+                self.unlink_skin_bone(item)
+        
+        return True
+    
     def create_skin_bone(self, inBoneArray, skipNub=True, mesh=True, link=True, skinBoneBaseName=""):
         """
         스킨 뼈대 생성.
@@ -1153,58 +1183,90 @@ class Bone:
         if len(skinBones) == 0:
             return False
         
+        pelvisBone = None
+        lastSpineBone = None
+        
+        for item in skinBones:
+            if rt.matchPattern(item.name.lower(), pattern="*pelvis*"):
+                pelvisBone = item
+            if rt.matchPattern(item.name.lower(), pattern="*spine*"):
+                lastSpineBone = item
+                foundChildren = self.get_every_children(item)
+                for child in foundChildren:
+                    if rt.matchPattern(child.name.lower(), pattern="*spine*"):
+                        lastSpineBone = child
+        
+        if pelvisBone is not None and lastSpineBone is not None:
+            for item in skinBones:
+                if rt.matchPattern(item.name.lower(), pattern="*thigh*"):
+                    item.parent = pelvisBone
+                if rt.matchPattern(item.name.lower(), pattern="*clavicle*"):
+                    item.parent = lastSpineBone
+        
         for item in skinBones:
-            if rt.matchPattern(item.name, pattern="*pelvis*"):
+            if rt.matchPattern(item.name.lower(), pattern="*pelvis*"):
                 self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*spine*"):
+            if rt.matchPattern(item.name.lower(), pattern="*spine*"):
                 self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*neck*"):
+            if rt.matchPattern(item.name.lower(), pattern="*neck*"):
                 self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*head*"):
+            if rt.matchPattern(item.name.lower(), pattern="*head*"):
                 self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*thigh*l"):
+            if rt.matchPattern(item.name.lower(), pattern="*thigh*l"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*calf*l"):
+            if rt.matchPattern(item.name.lower(), pattern="*calf*l"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*foot*l"):
+            if rt.matchPattern(item.name.lower(), pattern="*foot*l"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*ball*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*ball*r"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
                 
-            if rt.matchPattern(item.name, pattern="*clavicle*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*clavicle*r"):
                 self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*upperarm*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*upperarm*r"):
                 self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*lowerarm*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*lowerarm*r"):
                 self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*hand*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*hand*r"):
                 self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
             
-            if rt.matchPattern(item.name, pattern="*thumb*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*thumb*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name.lower(), pattern="*index*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name.lower(), pattern="*middle*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name.lower(), pattern="*ring*r"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*index*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*pinky*r"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*middle*r"):
+                
+            if rt.matchPattern(item.name.lower(), pattern="*finger0*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name.lower(), pattern="*finger1*r"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*ring*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*finger2*r"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
-            if rt.matchPattern(item.name, pattern="*pinky*r"):
+            if rt.matchPattern(item.name.lower(), pattern="*finger3*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name.lower(), pattern="*finger4*r"):
                 self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
             
-            if rt.matchPattern(item.name, pattern="*metacarpal*"):
+            if rt.matchPattern(item.name.lower(), pattern="*metacarpal*"):
                 tempArray = self.name._split_to_array(item.name)
                 item.name = self.name._combine(tempArray, inFilChar="_")
                 item.name = self.name.remove_name_part("Base", item.name)
             
             self.anim.save_xform(item)
             
-        self.relink_missing_skin_bones_for_ue5manny(skinBones)
+        if isHuman:
+            self.relink_missing_skin_bones_for_ue5manny(skinBones)
         
         self.link_skin_bones(skinBones, sortedBipBones)
         for item in skinBones:
             self.anim.save_xform(item)
         
-        return skinBones
+        return (skinBones + missingBipBones)
     
     def set_bone_on(self, inBone):
         """