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

pyjallib/max/twistBone.py

@@ -3,7 +3,11 @@
 
 """
 트위스트 뼈대(Twist Bone) 모듈 - 3ds Max용 트위스트 뼈대 생성 관련 기능 제공
-원본 MAXScript의 twistBone.ms를 Python으로 변환하였으며, pymxs 모듈 기반으로 구현됨
+
+이 모듈은 3D 캐릭터 리깅에서 사용되는 트위스트 뼈대를 생성하고 제어하는 기능을 제공합니다.
+트위스트 뼈대는 팔이나 다리의 회전 움직임을 더욱 자연스럽게 표현하기 위해 사용됩니다.
+원본 MAXScript의 twistBone.ms를 Python으로 변환하였으며, pymxs 모듈 기반으로 구현되어
+3ds Max 내에서 스크립트 형태로 실행할 수 있습니다.
 """
 
 from pymxs import runtime as rt
@@ -15,530 +19,328 @@ from .constraint import Constraint
 from .bip import Bip
 from .bone import Bone
 
+from .boneChain import BoneChain
+
 
 class TwistBone:
     """
     트위스트 뼈대(Twist Bone) 관련 기능을 제공하는 클래스.
+    
+    이 클래스는 3ds Max에서 트위스트 뼈대를 생성하고 제어하는 다양한 기능을 제공합니다.
     MAXScript의 _TwistBone 구조체 개념을 Python으로 재구현한 클래스이며,
     3ds Max의 기능들을 pymxs API를 통해 제어합니다.
+    
+    트위스트 뼈대는 상체(Upper)와 하체(Lower) 두 가지 타입으로 생성이 가능하며,
+    각각 다른 회전 표현식을 사용하여 자연스러운 회전 움직임을 구현합니다.
     """
     
-    def __init__(self, nameService=None, animService=None, constService=None, bipService=None, boneService=None):
+    def __init__(self, nameService=None, animService=None, constraintService=None, bipService=None, boneService=None):
         """
-        클래스 초기화.
+        TwistBone 클래스 초기화.
+        
+        의존성 주입 방식으로 필요한 서비스들을 외부에서 제공받거나 내부에서 생성합니다.
+        서비스들이 제공되지 않을 경우 각 서비스의 기본 인스턴스를 생성하여 사용합니다.
         
         Args:
-            nameService: 이름 처리 서비스 (제공되지 않으면 새로 생성)
-            animService: 애니메이션 서비스 (제공되지 않으면 새로 생성)
-            constService: 제약 서비스 (제공되지 않으면 새로 생성)
-            bipService: 바이페드 서비스 (제공되지 않으면 새로 생성)
+            nameService (Name, optional): 이름 처리 서비스. 기본값은 None이며, 제공되지 않으면 새로 생성됩니다.
+            animService (Anim, optional): 애니메이션 서비스. 기본값은 None이며, 제공되지 않으면 새로 생성됩니다.
+            constraintService (Constraint, optional): 제약 서비스. 기본값은 None이며, 제공되지 않으면 새로 생성됩니다.
+            bipService (Bip, optional): 바이페드 서비스. 기본값은 None이며, 제공되지 않으면 새로 생성됩니다.
+            boneService (Bone, optional): 뼈대 서비스. 기본값은 None이며, 제공되지 않으면 새로 생성됩니다.
         """
         self.name = nameService if nameService else Name()
         self.anim = animService if animService else Anim()
         # Ensure dependent services use the potentially newly created instances
-        self.const = constService if constService else Constraint(nameService=self.name)
+        self.const = constraintService if constraintService else Constraint(nameService=self.name)
         self.bip = bipService if bipService else Bip(animService=self.anim, nameService=self.name)
         self.bone = boneService if boneService else Bone(nameService=self.name, animService=self.anim)
         
-        # 표현식 초기화
-        self._init_expressions()
-    
-    def _init_expressions(self):
-        """표현식 초기화"""
-        # 허벅지(Thigh) 표현식
-        self.thighExpression = (
-            "try(\n"
-            "TM=Limb.transform*inverse Limb.parent.transform\n"
-            "vector=normalize (cross -TM.row1 [1,0,0])\n"
-            "angle=acos -(normalize TM.row1).x\n"
-            "(quat 0 1 0 0)*(quat angle vector)*inverse TM.rotation)\n"
-            "catch((quat 0 0 0 1))"
-        )
-        
-        # 허벅지 추가 표현식
-        self.thighExtraExpression = (
-            "try(\n"
-            "(Limb.transform*inverse LimbParent.transform).rotation\n"
-            ")catch((quat 0 0 0 1))"
-        )
-        
-        # 종아리(Calf) 표현식
-        self.calfExpression = (
-            "try(\n"
-            "TM=Limb.transform*inverse Limb.parent.transform\n"
-            "vector=normalize (cross TM.row1 [1,0,0])\n"
-            "angle=acos (normalize TM.row1).x\n"
-            "TM.rotation*(quat -angle vector))\n"
-            "catch((quat 0 0 0 1))"
-        )
-        
-        # 종아리 추가 표현식
-        self.calfExtraExpression = (
-            "try(dependson TB\n"
-            "TB.rotation.controller[1].value\n"
-            ")catch((quat 0 0 0 1))"
-        )
-        
-        # 상완(Upper Arm) 표현식
-        self.upperArmExpression = (
-            "try(\n"
-            "TM=Limb.transform*inverse Limb.parent.transform\n"
-            "vector=normalize (cross TM.row1 [1,0,0])\n"
-            "angle=acos (normalize TM.row1).x\n"
-            "(quat angle vector)*inverse TM.rotation)\n"
-            "catch((quat 0 0 0 1))"
-        )
-        
-        # 상완 추가 표현식
-        self.upperArmExtraExpression = (
-            "try(\n"
-            "(Limb.transform*inverse LimbParent.transform).rotation\n"
-            ")catch((quat 0 0 0 1))"
-        )
-        
-        # 오른쪽 전완(Forearm) 표현식
-        self.rForeArmExpression = (
-            "try(\n"
-            "TM=(matrix3 [1,0,0] [0,0,-1] [0,1,0] [0,0,0])*Limb.transform*inverse Limb.parent.transform\n"
-            "vector=normalize (cross TM.row1 [1,0,0])\n"
-            "angle=acos (normalize TM.row1).x\n"
-            "TM.rotation*(quat -angle vector))\n"
-            "catch((quat 0 0 0 1))"
-        )
-        
-        # 왼쪽 전완(Forearm) 표현식
-        self.lForeArmExpression = (
-            "try(\n"
-            "TM=(matrix3 [1,0,0] [0,0,1] [0,-1,0] [0,0,0])*Limb.transform*inverse Limb.parent.transform\n"
-            "vector=normalize (cross TM.row1 [1,0,0])\n"
-            "angle=acos (normalize TM.row1).x\n"
-            "TM.rotation*(quat -angle vector))\n"
-            "catch((quat 0 0 0 1))"
+        # 객체 속성 초기화
+        self.limb = None
+        self.child = None
+        self.twistNum = 0
+        self.bones = []
+        self.twistType = ""
+        
+        self.upperTwistBoneExpression = (
+            "localTm = limb.transform * (inverse limbParent.transform)\n"
+            "tm = localTm * inverse(localRefTm)\n"
+            "\n"
+            "q = tm.rotation\n"
+            "\n"
+            "axis = [1,0,0]\n"
+            "proj = (dot q.axis axis) * axis\n"
+            "twist = quat q.angle proj\n"
+            "twist = normalize twist\n"
+            "--swing = tm.rotation * (inverse twist)\n"
+            "\n"
+            "inverse twist\n"
         )
         
-        # 전완 추가 표현식
-        self.foreArmExtraExpression = (
-            "try(dependson TB\n"
-            "TB.rotation.controller[1].value\n"
-            ")catch((quat 0 0 0 1))"
+        self.lowerTwistBoneExpression = (
+            "localTm = limb.transform * (inverse limbParent.transform)\n"
+            "tm = localTm * inverse(localRefTm)\n"
+            "\n"
+            "q = tm.rotation\n"
+            "\n"
+            "axis = [1,0,0]\n"
+            "proj = (dot q.axis axis) * axis\n"
+            "twist = quat q.angle proj\n"
+            "twist = normalize twist\n"
+            "--swing = tm.rotation * (inverse twist)\n"
+            "\n"
+            "twist\n"
         )
-    
-    def create_bones(self, inObj, inChild, inTwistNum, inExpression, inExtraExpression, inControllerLimb, inWeightVar):
-        """
-        트위스트 뼈대 체인 생성
-        
-        Args:
-            inObj: 시작 객체
-            inChild: 끝 객체
-            inTwistNum: 트위스트 뼈대 개수
-            inExpression: 기본 회전 표현식
-            inExtraExpression: 추가 회전 표현식
-            inControllerLimb: 컨트롤러 대상 팔다리
-            inWeightVar: 가중치
             
-        Returns:
-            생성된 트위스트 뼈대 체인 배열
+    def reset(self):
         """
-        Limb = inObj
-        distanceVar = rt.distance(Limb, inChild)
-        
-        TBExpression = inExpression
-        ControllerLimb = inControllerLimb
-        weightVar = inWeightVar
-        
-        boneChainArray = []
-        
-        # 첫 번째 트위스트 뼈대 생성
-        TwistBone = rt.BoneSys.createBone(
-            Limb.transform.position,
-            inChild.transform.position,
-            rt.Point3(0, 0, 1)
-        )
-        boneName = self.name.get_string(inObj.name) + "Twist"
-        TwistBone.name = self.name.replace_Index(boneName, "0")
-        TwistBone.transform = Limb.transform
-        TwistBone.parent = Limb
-        TwistBone.length = distanceVar / inTwistNum
-        TwistBone.width = distanceVar / 8
-        TwistBone.height = TwistBone.width
-        TwistBone.taper = 0
-        TwistBone.sidefins = False
-        TwistBone.frontfin = False
-        TwistBone.backfin = False
-        
-        # 회전 컨트롤러 설정
-        TBRotListController = self.const.assign_rot_list(TwistBone)
-        TBController = rt.Rotation_Script()
-        TBController.addNode("Limb", ControllerLimb)
-        TBController.setExpression(TBExpression)
-        
-        rt.setPropertyController(TBRotListController, "Available", TBController)
-        TBRotListController.delete(1)
-        TBRotListController.setActive(TBRotListController.count)
-        TBRotListController.weight[0] = weightVar
-        
-        boneChainArray.append(TwistBone)
-        
-        # 추가 회전 컨트롤러 설정
-        TBExtraController = rt.Rotation_Script()
-        if rt.matchPattern(inExtraExpression, pattern="*\nTB.*"):
-            TBExtraController.addNode("TB", TwistBone)
-        else:
-            TBExtraController.addNode("Limb", Limb)
-            TBExtraController.addNode("LimbParent", TwistBone)
-        TBExtraController.setExpression(inExtraExpression)
-        
-        PrevTBE = TwistBone
-        
-        # 추가 트위스트 뼈대 생성 (2개 이상인 경우)
-        if inTwistNum > 1:
-            for j in range(2, inTwistNum):
-                TwistBoneExtra = rt.BoneSys.createBone(
-                    rt.Point3(0, 0, 0),
-                    rt.Point3(1, 0, 0),
-                    rt.Point3(0, 0, 1)
-                )
-                matAux = rt.matrix3(1)
-                matAux.position = rt.Point3(distanceVar/inTwistNum, 0, 0)
-                TwistBoneExtra.transform = matAux * PrevTBE.transform
-                TwistBoneExtra.name = self.name.replace_Index(boneName, str(j-1))
-                TwistBoneExtra.parent = PrevTBE
-                TwistBoneExtra.length = distanceVar / inTwistNum
-                TwistBoneExtra.width = PrevTBE.width
-                TwistBoneExtra.height = PrevTBE.height
-                TwistBoneExtra.taper = 0
-                TwistBoneExtra.sidefins = False
-                TwistBoneExtra.frontfin = False
-                TwistBoneExtra.backfin = False
-                
-                # 회전 컨트롤러 설정
-                TBExtraRotListController = self.const.assign_rot_list(TwistBoneExtra)
-                rt.setPropertyController(TBExtraRotListController, "Available", TBExtraController)
-                TBExtraRotListController.delete(1)
-                TBExtraRotListController.setActive(TBExtraRotListController.count)
-                TBExtraRotListController.weight[0] = 100 / (inTwistNum - 1)
-                
-                PrevTBE = TwistBoneExtra
-                boneChainArray.append(TwistBoneExtra)
-            
-            # 마지막 트위스트 뼈대 생성
-            TwistBoneEnd = rt.BoneSys.createBone(
-                rt.Point3(0, 0, 0),
-                rt.Point3(1, 0, 0),
-                rt.Point3(0, 0, 1)
-            )
-            matAux = rt.matrix3(1)
-            matAux.position = rt.Point3(distanceVar/inTwistNum, 0, 0)
-            TwistBoneEnd.transform = matAux * PrevTBE.transform
-            TwistBoneEnd.name = self.name.replace_Index(boneName, str(inTwistNum-1))
-            TwistBoneEnd.parent = inObj
-            TwistBoneEnd.length = distanceVar / inTwistNum
-            TwistBoneEnd.width = PrevTBE.width
-            TwistBoneEnd.height = PrevTBE.height
-            TwistBoneEnd.taper = 0
-            TwistBoneEnd.sidefins = False
-            TwistBoneEnd.frontfin = False
-            TwistBoneEnd.backfin = False
-            
-            boneChainArray.append(TwistBoneEnd)
+        클래스의 주요 컴포넌트들을 초기화합니다.
+        서비스가 아닌 클래스 자체의 작업 데이터를 초기화하는 함수입니다.
         
-        return boneChainArray
-    
-    def reorder_bones(self, inBoneChainArray):
+        Returns:
+            self: 메소드 체이닝을 위한 자기 자신 반환
         """
-        뼈대 체인의 순서 재배치
+        self.limb = None
+        self.child = None
+        self.twistNum = 0
+        self.bones = []
+        self.twistType = ""
         
-        Args:
-            inBoneChainArray: 재배치할 뼈대 체인 배열
+        return self
             
-        Returns:
-            재배치된 뼈대 체인 배열
+    def create_upper_limb_bones(self, inObj, inChild, twistNum=4):
         """
-        boneChainArray = rt.deepcopy(inBoneChainArray)
-        returnBoneArray = []
+        상체(팔, 어깨 등) 부분의 트위스트 뼈대를 생성하는 메소드.
         
-        # 첫 번째와 마지막 뼈대 가져오기
-        firstBone = boneChainArray[0]
-        lastBone = boneChainArray[-1]
-        returnBoneArray.append(lastBone)
-        
-        # 뼈대가 2개 이상인 경우 위치 조정
-        if len(boneChainArray) > 1:
-            self.anim.move_local(firstBone, firstBone.length, 0, 0)
-            self.anim.move_local(lastBone, -(firstBone.length * (len(boneChainArray)-1)), 0, 0)
-        
-        # 중간 뼈대들을 새 배열에 추가
-        for i in range(len(boneChainArray)-1):
-            returnBoneArray.append(boneChainArray[i])
-        
-        # 새로운 순서대로 이름 재설정
-        for i in range(len(returnBoneArray)):
-            returnBoneArray[i].name = self.name.replace_Index(boneChainArray[i].name, str(i))
-        
-        return returnBoneArray
-    
-    def create_upperArm_type(self, inObj, inTwistNum):
-        """
-        상완(Upper Arm) 타입의 트위스트 뼈대 생성
+        상체용 트위스트 뼈대는 부모 객체(inObj)의 위치에서 시작하여 
+        자식 객체(inChild) 방향으로 여러 개의 뼈대를 생성합니다.
+        생성된 뼈대들은 스크립트 컨트롤러를 통해 자동으로 회전되어
+        자연스러운 트위스트 움직임을 표현합니다.
         
         Args:
-            inObj: 상완 뼈대 객체
-            inTwistNum: 트위스트 뼈대 개수
-            
-        Returns:
-            생성된 트위스트 뼈대 체인 또는 False(실패 시)
-        """
-        if inObj.parent is None or inObj.children.count == 0:
-            return False
-        
-        weightVal = 100.0
-        
-        return self.create_bones(
-            inObj,
-            inObj.children[0],
-            inTwistNum,
-            self.upperArmExpression,
-            self.upperArmExtraExpression,
-            inObj,
-            weightVal
-        )
-    
-    def create_foreArm_type(self, inObj, inTwistNum, reorder=True):
-        """
-        전완(Forearm) 타입의 트위스트 뼈대 생성
+            inObj: 트위스트 뼈대의 부모 객체(뼈). 일반적으로 상완 또는 대퇴부에 해당합니다.
+            inChild: 자식 객체(뼈). 일반적으로 전완 또는 하퇴부에 해당합니다.
+            twistNum (int, optional): 생성할 트위스트 뼈대의 개수. 기본값은 4입니다.
         
-        Args:
-            inObj: 전완 뼈대 객체
-            inTwistNum: 트위스트 뼈대 개수
-            side: 좌/우측 ("left" 또는 "right", 기본값: "left")
-            
         Returns:
-            생성된 트위스트 뼈대 체인 또는 False(실패 시)
+            BoneChain: 생성된 트위스트 뼈대 BoneChain 객체
         """
-        if inObj.parent is None or inObj.children.count == 0:
-            return False
-        
-        controllerLimb = None
-        weightVal = 100.0
+        limb = inObj
+        distance = rt.distance(limb, inChild)
+        facingDirVec = inChild.transform.position - inObj.transform.position
+        inObjXAxisVec = inObj.objectTransform.row1
+        distanceDir = 1.0 if rt.dot(inObjXAxisVec, facingDirVec) > 0 else -1.0
+        offssetAmount = (distance / twistNum) * distanceDir
         
-        # 좌/우측에 따른 표현식 선택
-        TBExpression = self.lForeArmExpression if self.bip.is_left_node(inObj) else self.rForeArmExpression
+        boneChainArray = []
         
-        # Biped 컨트롤러 노드 설정
-        if self.bip.is_left_node(inObj):
-            controllerLimb = rt.biped.getNode(inObj.controller.rootNode, rt.Name("lArm"), link=4)
-        else:
-            controllerLimb = rt.biped.getNode(inObj.controller.rootNode, rt.Name("rArm"), link=4)
+        # 첫 번째 트위스트 뼈대 생성
+        boneName = self.name.add_suffix_to_real_name(inObj.name, self.name._get_filtering_char(inObj.name) + "Twist")
+        if inObj.name[0].islower():
+            boneName = boneName.lower()
+        twistBone = self.bone.create_nub_bone(boneName, 2)
+        twistBone.name = self.name.replace_name_part("Index", boneName, "1")
+        twistBone.name = self.name.remove_name_part("Nub", twistBone.name)
+        twistBone.transform = limb.transform
+        twistBone.parent = limb
+        twistBoneLocalRefTM = limb.transform * rt.inverse(limb.parent.transform)
+        
+        twistBoneRotListController = self.const.assign_rot_list(twistBone)
+        twistBoneController = rt.Rotation_Script()
+        twistBoneController.addConstant("localRefTm", twistBoneLocalRefTM)
+        twistBoneController.addNode("limb", limb)
+        twistBoneController.addNode("limbParent", limb.parent)
+        twistBoneController.setExpression(self.upperTwistBoneExpression)
+        twistBoneController.update()
+        
+        rt.setPropertyController(twistBoneRotListController, "Available", twistBoneController)
+        twistBoneRotListController.delete(1)
+        twistBoneRotListController.setActive(twistBoneRotListController.count)
+        twistBoneRotListController.weight[0] = 100.0
+        
+        boneChainArray.append(twistBone)
+        
+        if twistNum > 1:
+            lastBone = self.bone.create_nub_bone(boneName, 2)
+            lastBone.name = self.name.replace_name_part("Index", boneName, str(twistNum))
+            lastBone.name = self.name.remove_name_part("Nub", lastBone.name)
+            lastBone.transform = limb.transform
+            lastBone.parent = limb
+            self.anim.move_local(lastBone, offssetAmount*(twistNum-1), 0, 0)
             
-        if inTwistNum > 1:
-            weightVal = 100 / (inTwistNum - 1)
+            weightVal = 100.0 / (twistNum-1)
             
-        createdBones = self.create_bones(
-            inObj,
-            controllerLimb,
-            inTwistNum,
-            TBExpression,
-            self.foreArmExtraExpression,
-            controllerLimb,
-            weightVal
-        )
-        
-        return self.reorder_bones(createdBones) if reorder else createdBones
-    
-    def create_thigh_type(self, inObj, inTwistNum):
-        """
-        허벅지(Thigh) 타입의 트위스트 뼈대 생성
-        
-        Args:
-            inObj: 허벅지 뼈대 객체
-            inTwistNum: 트위스트 뼈대 개수
+            if twistNum > 2:
+                for i in range(1, twistNum-1):
+                    twistExtraBone = self.bone.create_nub_bone(boneName, 2)
+                    twistExtraBone.name = self.name.replace_name_part("Index", boneName, str(i+1))
+                    twistExtraBone.name = self.name.remove_name_part("Nub", twistExtraBone.name)
+                    twistExtraBone.transform = limb.transform
+                    twistExtraBone.parent = limb
+                    self.anim.move_local(twistExtraBone, offssetAmount*i, 0, 0)
+                    
+                    twistExtraBoneRotListController = self.const.assign_rot_list(twistExtraBone)
+                    twistExtraBoneController = rt.Rotation_Script()
+                    twistExtraBoneController.addConstant("localRefTm", twistBoneLocalRefTM)
+                    twistExtraBoneController.addNode("limb", limb)
+                    twistExtraBoneController.addNode("limbParent", limb.parent)
+                    twistExtraBoneController.setExpression(self.upperTwistBoneExpression)
+                    
+                    rt.setPropertyController(twistExtraBoneRotListController, "Available", twistExtraBoneController)
+                    twistExtraBoneRotListController.delete(1)
+                    twistExtraBoneRotListController.setActive(twistExtraBoneRotListController.count)
+                    twistExtraBoneRotListController.weight[0] = weightVal * (twistNum-1-i)
+                    
+                    boneChainArray.append(twistExtraBone)
             
-        Returns:
-            생성된 트위스트 뼈대 체인 또는 False(실패 시)
-        """
-        if inObj.parent is None or inObj.children.count == 0:
-            return False
-        
-        controllerLimb = None
-        weightVal = 100
-        
-        return self.create_bones(
-            inObj,
-            inObj.children[0],
-            inTwistNum,
-            self.thighExpression,
-            self.thighExtraExpression,
-            inObj,
-            weightVal
-        )
-    
-    def create_calf_type(self, inObj, inTwistNum, reorder=True):
-        """
-        종아리(Calf) 타입의 트위스트 뼈대 생성
+            boneChainArray.append(lastBone)
         
-        Args:
-            inObj: 종아리 뼈대 객체
-            inTwistNum: 트위스트 뼈대 개수
-            side: 좌/우측 ("left" 또는 "right", 기본값: "left")
-            
-        Returns:
-            생성된 트위스트 뼈대 체인 또는 False(실패 시)
-        """
-        if inObj.parent is None or inObj.children.count == 0:
-            return False
-        
-        controllerLimb = None
-        weightVal = 100
+        # 결과를 BoneChain 형태로 준비
+        result = {
+            "Bones": boneChainArray,
+            "Helpers": [],
+            "SourceBones": [inObj, inChild],
+            "Parameters": [twistNum, "Upper"]
+        }
         
-        # Biped 컨트롤러 노드 설정
-        if self.bip.is_left_node(inObj):
-            controllerLimb = rt.biped.getNode(inObj.controller.rootNode, rt.Name("lLeg"), link=3)
-        else:
-            controllerLimb = rt.biped.getNode(inObj.controller.rootNode, rt.Name("rLeg"), link=3)
-        
-        # 복수 뼈대인 경우 가중치 조정
-        if inTwistNum > 1:
-            weightVal = 100 / (inTwistNum - 1)
-            
-        createdBones = self.create_bones(
-            inObj,
-            controllerLimb,
-            inTwistNum,
-            self.calfExpression,
-            self.calfExtraExpression,
-            controllerLimb,
-            weightVal
-        )
+        # 메소드 호출 후 데이터 초기화
+        self.reset()
         
-        return self.reorder_bones(createdBones) if reorder else createdBones
-    
-    def create_bend_type(self):
-        """
-        굽힘(Bend) 타입의 트위스트 뼈대 생성
-        (아직 구현되지 않음)
-        """
-        pass
-    
-    def get_upperArm_type(self, inObj):
+        return BoneChain.from_result(result)
+
+    def create_lower_limb_bones(self, inObj, inChild, twistNum=4):
         """
-        상완(Upper Arm) 타입의 트위스트 뼈대 가져오기
+        하체(팔뚝, 다리 등) 부분의 트위스트 뼈대를 생성하는 메소드.
+        
+        하체용 트위스트 뼈대는 부모 객체(inObj)의 위치에서 시작하여 
+        자식 객체(inChild) 쪽으로 여러 개의 뼈대를 생성합니다.
+        상체와는 다른 회전 표현식을 사용하여 하체에 적합한 트위스트 움직임을 구현합니다.
         
         Args:
-            inObj: 상완 뼈대 객체
-            
+            inObj: 트위스트 뼈대의 부모 객체(뼈). 일반적으로 전완 또는 하퇴부에 해당합니다.
+            inChild: 자식 객체(뼈). 일반적으로 손목 또는 발목에 해당합니다.
+            twistNum (int, optional): 생성할 트위스트 뼈대의 개수. 기본값은 4입니다.
+        
         Returns:
-            상완 타입의 트위스트 뼈대 또는 False(실패 시)
+            BoneChain: 생성된 트위스트 뼈대 BoneChain 객체
         """
-        returnVal = []
-        
-        parentBipObj = None
+        limb = inChild
+        distance = rt.distance(inObj, inChild)
+        facingDirVec = inChild.transform.position - inObj.transform.position
+        inObjXAxisVec = inObj.objectTransform.row1
+        distanceDir = 1.0 if rt.dot(inObjXAxisVec, facingDirVec) > 0 else -1.0
+        offssetAmount = (distance / twistNum) * distanceDir
         
-        if not self.bip.is_biped_object(inObj):
-            return returnVal
+        boneChainArray = []
         
-        if self.bip.is_left_node(inObj):
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("lArm"), link=2)
-        else:
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("rArm"), link=2)
+        # 첫 번째 트위스트 뼈대 생성
+        boneName = self.name.add_suffix_to_real_name(inObj.name, self.name._get_filtering_char(inObj.name) + "Twist")
+        if inObj.name[0].islower():
+            boneName = boneName.lower()
+        twistBone = self.bone.create_nub_bone(boneName, 2)
+        twistBone.name = self.name.replace_name_part("Index", boneName, "1")
+        twistBone.name = self.name.remove_name_part("Nub", twistBone.name)
+        twistBone.transform = inObj.transform
+        twistBone.parent = inObj
+        self.anim.move_local(twistBone, offssetAmount*(twistNum-1), 0, 0)
+        twistBoneLocalRefTM = limb.transform * rt.inverse(limb.parent.transform)
+        
+        twistBoneRotListController = self.const.assign_rot_list(twistBone)
+        twistBoneController = rt.Rotation_Script()
+        twistBoneController.addConstant("localRefTm", twistBoneLocalRefTM)
+        twistBoneController.addNode("limb", limb)
+        twistBoneController.addNode("limbParent", limb.parent)
+        twistBoneController.setExpression(self.lowerTwistBoneExpression)
+        twistBoneController.update()
+        
+        rt.setPropertyController(twistBoneRotListController, "Available", twistBoneController)
+        twistBoneRotListController.delete(1)
+        twistBoneRotListController.setActive(twistBoneRotListController.count)
+        twistBoneRotListController.weight[0] = 100.0
+        
+        if twistNum > 1:
+            lastBone = self.bone.create_nub_bone(boneName, 2)
+            lastBone.name = self.name.replace_name_part("Index", boneName, str(twistNum))
+            lastBone.name = self.name.remove_name_part("Nub", lastBone.name)
+            lastBone.transform = inObj.transform
+            lastBone.parent = inObj
+            self.anim.move_local(lastBone, 0, 0, 0)
             
-        children = self.bone.get_every_children(parentBipObj)
-        for child in children:
-            if rt.matchPattern(child.name, pattern="*Twist*") and rt.classOf(child) == rt.BoneGeometry:
-                returnVal.append(child)
-        
-        returnVal = self.name.sort_by_name(returnVal)
-        
-        return returnVal
-    
-    def get_foreArm_type(self, inObj):
-        """
-        전완(Forearm) 타입의 트위스트 뼈대 가져오기
-        
-        Args:
-            inObj: 전완 뼈대 객체
+            weightVal = 100.0 / (twistNum-1)
             
-        Returns:
-            전완 타입의 트위스트 뼈대 또는 False(실패 시)
-        """
-        returnVal = []
-        
-        parentBipObj = None
-        
-        if not self.bip.is_biped_object(inObj):
-            return returnVal
-        
-        if self.bip.is_left_node(inObj):
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("lArm"), link=3)
-        else:
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("rArm"), link=3)
+            if twistNum > 2:
+                for i in range(1, twistNum-1):
+                    twistExtraBone = self.bone.create_nub_bone(boneName, 2)
+                    twistExtraBone.name = self.name.replace_name_part("Index", boneName, str(i+1))
+                    twistExtraBone.name = self.name.remove_name_part("Nub", twistExtraBone.name)
+                    twistExtraBone.transform = inObj.transform
+                    twistExtraBone.parent = inObj
+                    self.anim.move_local(twistExtraBone, offssetAmount*(twistNum-1-i), 0, 0)
+                    
+                    twistExtraBoneRotListController = self.const.assign_rot_list(twistExtraBone)
+                    twistExtraBoneController = rt.Rotation_Script()
+                    twistExtraBoneController.addConstant("localRefTm", twistBoneLocalRefTM)
+                    twistExtraBoneController.addNode("limb", limb)
+                    twistExtraBoneController.addNode("limbParent", limb.parent)
+                    twistExtraBoneController.setExpression(self.lowerTwistBoneExpression)
+                    
+                    rt.setPropertyController(twistExtraBoneRotListController, "Available", twistExtraBoneController)
+                    twistExtraBoneRotListController.delete(1)
+                    twistExtraBoneRotListController.setActive(twistExtraBoneRotListController.count)
+                    twistExtraBoneRotListController.weight[0] = weightVal * (twistNum-1-i)
+                    
+                    boneChainArray.append(twistExtraBone)
             
-        children = self.bone.get_every_children(parentBipObj)
-        for child in children:
-            if rt.matchPattern(child.name, pattern="*Twist*") and rt.classOf(child) == rt.BoneGeometry:
-                returnVal.append(child)
+            boneChainArray.append(lastBone)
         
-        returnVal = self.name.sort_by_name(returnVal)
+        # 결과를 BoneChain 형태로 준비
+        result = {
+            "Bones": boneChainArray,
+            "Helpers": [],
+            "SourceBones": [inObj, inChild],
+            "Parameters": [twistNum, "Lower"]
+        }
         
-        return returnVal
+        # 메소드 호출 후 데이터 초기화
+        self.reset()
+        
+        return BoneChain.from_result(result)
     
-    def get_thigh_type(self, inObj):
+    def create_bones_from_chain(self, inBoneChain: BoneChain):
         """
-        허벅지(Thigh) 타입의 트위스트 뼈대 가져오기
+        기존 BoneChain 객체에서 트위스트 본을 생성합니다.
+        기존 설정을 복원하거나 저장된 데이터에서 트위스트 본 셋업을 재생성할 때 사용합니다.
         
         Args:
-            inObj: 허벅지 뼈대 객체
-            
+            inBoneChain (BoneChain): 트위스트 본 정보를 포함한 BoneChain 객체
+        
         Returns:
-            허벅지 타입의 트위스트 뼈대 또는 False(실패 시)
+            BoneChain: 업데이트된 BoneChain 객체 또는 실패 시 None
         """
-        returnVal = []
-        
-        parentBipObj = None
-        
-        if not self.bip.is_biped_object(inObj):
-            return returnVal
-        
-        if self.bip.is_left_node(inObj):
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("lLeg"), link=1)
-        else:
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("rLeg"), link=1)
+        if not inBoneChain or inBoneChain.is_empty():
+            return None
             
-        children = self.bone.get_every_children(parentBipObj)
-        for child in children:
-            if rt.matchPattern(child.name, pattern="*Twist*") and rt.classOf(child) == rt.BoneGeometry:
-                returnVal.append(child)
-        
-        returnVal = self.name.sort_by_name(returnVal)
-        
-        return returnVal
-    
-    def get_calf_type(self, inObj):
-        """
-        종아리(Calf) 타입의 트위스트 뼈대 가져오기
-        
-        Args:
-            inObj: 종아리 뼈대 객체
+        # 기존 객체 삭제
+        inBoneChain.delete()
             
-        Returns:
-            종아리 타입의 트위스트 뼈대 또는 False(실패 시)
-        """
-        returnVal = []
-        
-        parentBipObj = None
+        # BoneChain에서 필요한 정보 추출
+        sourceBones = inBoneChain.sourceBones
+        parameters = inBoneChain.parameters
         
-        if not self.bip.is_biped_object(inObj):
-            return returnVal
-        
-        if self.bip.is_left_node(inObj):
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("lLeg"), link=2)
-        else:
-            parentBipObj = rt.biped.getNode(inObj.controller.rootNode, rt.Name("rLeg"), link=2)
+        # 필수 소스 본 확인
+        if len(sourceBones) < 2 or not rt.isValidNode(sourceBones[0]) or not rt.isValidNode(sourceBones[1]):
+            return None
             
-        children = self.bone.get_every_children(parentBipObj)
-        for child in children:
-            if rt.matchPattern(child.name, pattern="*Twist*") and rt.classOf(child) == rt.BoneGeometry:
-                returnVal.append(child)
+        # 파라미터 가져오기 (또는 기본값 사용)
+        twistNum = parameters[0] if len(parameters) > 0 else 4
+        twistType = parameters[1] if len(parameters) > 1 else "Upper"
         
-        returnVal = self.name.sort_by_name(returnVal)
+        # 본 생성
+        inObj = sourceBones[0]
+        inChild = sourceBones[1]
         
-        return returnVal
+        # 타입에 따라 적절한 방식으로 트위스트 본 생성
+        if twistType == "Upper":
+            return self.create_upper_limb_bones(inObj, inChild, twistNum)
+        else:
+            return self.create_lower_limb_bones(inObj, inChild, twistNum)