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

pyjallib/max/bone.py

@@ -239,7 +239,7 @@ class Bone:
         nubBone.backfin = False
         nubBone.sidefins = False
         nubBone.name = self.name.remove_name_part("Index", inName)
-        nubBone.name = self.name.replace_name_part("Nub", nubBone.name, "Nub")
+        nubBone.name = self.name.replace_name_part("Nub", nubBone.name, self.name.get_name_part_value_by_description("Nub", "Nub"))
         
         # 화면 갱신 재개
         rt.enableSceneRedraw()
@@ -679,18 +679,18 @@ class Bone:
             inOriBone: 원본 뼈대
         """
         self.anim.save_xform(inSkinBone)
-        self.anim.set_xform(inSkinBone)
+        self.anim.set_xform(inSkinBone, space="World")
         
         self.anim.save_xform(inOriBone)
-        self.anim.set_xform(inOriBone)
         
         rt.setPropertyController(inSkinBone.controller, "Scale", rt.scaleXYZ())
         
         linkConst = rt.link_constraint()
+        linkConst.addTarget(inOriBone, 0)
+        
         inSkinBone.controller = linkConst
         
-        self.anim.set_xform([inSkinBone], space="world")
-        linkConst.addTarget(inOriBone, 0)
+        self.anim.set_xform(inSkinBone, space="World")
     
     def link_skin_bones(self, inSkinBoneArray, inOriBoneArray):
         """
@@ -705,10 +705,48 @@ class Bone:
             False: 실패
         """
         if len(inSkinBoneArray) != len(inOriBoneArray):
+            print("Error: Skin bone array and original bone array must have the same length.")
             return False
         
-        for i in range(len(inSkinBoneArray)):
-            self.link_skin_bone(inSkinBoneArray[i], inOriBoneArray[i])
+        skinBoneDict = {}
+        oriBoneDict = {}
+        
+        # 스킨 뼈대 딕셔너리 생성 (이름과 패턴화된 이름을 함께 저장)
+        for item in inSkinBoneArray:
+            # 아이템 저장
+            skinBoneDict[item.name] = item
+            # 언더스코어를 별표로 변환한 패턴 생성
+            namePattern = self.name.remove_name_part("Base", item.name)
+            namePattern = namePattern.replace("_", "*")
+            skinBoneDict[item.name + "_Pattern"] = namePattern
+        
+        # 원본 뼈대 딕셔너리 생성 (이름과 패턴화된 이름을 함께 저장)
+        for item in inOriBoneArray:
+            # 아이템 저장
+            oriBoneDict[item.name] = item
+            # 공백을 별표로 변환한 패턴 생성
+            namePattern = self.name.remove_name_part("Base", item.name)
+            namePattern = namePattern.replace(" ", "*")
+            oriBoneDict[item.name + "_Pattern"] = namePattern
+        
+        # 정렬된 배열 생성
+        sortedSkinBoneArray = []
+        sortedOriBoneArray = []
+        
+        # 같은 패턴을 가진 뼈대들을 찾아 매칭
+        for skinName, skinBone in [(k, v) for k, v in skinBoneDict.items() if not k.endswith("_Pattern")]:
+            skinPattern = skinBoneDict[skinName + "_Pattern"]
+            
+            for oriName, oriBone in [(k, v) for k, v in oriBoneDict.items() if not k.endswith("_Pattern")]:
+                oriPattern = oriBoneDict[oriName + "_Pattern"]
+                
+                if rt.matchPattern(skinName, pattern=oriPattern):
+                    sortedSkinBoneArray.append(skinBone)
+                    sortedOriBoneArray.append(oriBone)
+                    break
+        # 링크 연결 수행
+        for i in range(len(sortedSkinBoneArray)):
+            self.link_skin_bone(sortedSkinBoneArray[i], sortedOriBoneArray[i])
         
         return True
     
@@ -732,17 +770,12 @@ class Bone:
         returnBones = []
         
         definedSkinBoneBaseName = self.name.get_name_part_value_by_description("Base", "SkinBone")
-        if skinBoneBaseName == "":
-            if definedSkinBoneBaseName == "":
-                skinBoneBaseName = "b"
-            else:
-                skinBoneBaseName = definedSkinBoneBaseName
         
         for i in range(len(inBoneArray)):
-            skinBoneName = self.name.replace_name_part("Base", inBoneArray[i].name, skinBoneBaseName)
+            skinBoneName = self.name.replace_name_part("Base", inBoneArray[i].name, definedSkinBoneBaseName)
             skinBoneName = self.name.replace_filtering_char(skinBoneName, skinBoneFilteringChar)
             
-            skinBone = self.create_nub_bone(f"{skinBoneBaseName}_TempSkin", 2)
+            skinBone = self.create_nub_bone(f"{definedSkinBoneBaseName}_TempSkin", 2)
             skinBone.name = skinBoneName
             skinBone.wireColor = rt.Color(255, 88, 199)
             skinBone.transform = inBoneArray[i].transform
@@ -767,12 +800,19 @@ class Bone:
         for i in range(len(inBoneArray)):
             oriParentObj = inBoneArray[i].parent
             if oriParentObj is not None:
-                skinBoneParentObjName = self.name.replace_base(oriParentObj.name, skinBoneBaseName)
+                skinBoneParentObjName = self.name.replace_name_part("Base", oriParentObj.name, definedSkinBoneBaseName)
                 skinBoneParentObjName = self.name.replace_filtering_char(skinBoneParentObjName, skinBoneFilteringChar)
                 bones[i].parent = rt.getNodeByName(skinBoneParentObjName)
             else:
                 bones[i].parent = None
         
+        for item in bones:
+            item.showLinks = True
+            item.showLinksOnly = True
+        
+        for item in bones:
+            item.name = self.name.replace_name_part("Base", item.name, skinBoneBaseName)
+        
         if link:
             self.link_skin_bones(bones, inBoneArray)
         
@@ -798,7 +838,7 @@ class Bone:
             skipNub: Nub 뼈대 건너뛰기 (기본값: True)
             mesh: 메시 스냅샷 사용 (기본값: False)
             link: 원본 뼈대에 연결 (기본값: True)
-            skinBoneBaseName: 스킨 뼈대 기본 이름 (기본값: "b")
+            skinBoneBaseName: 스킨 뼈대 기본 이름 (기본값: "")
             
         Returns:
             생성된 스킨 뼈대 배열
@@ -844,6 +884,291 @@ class Bone:
         
         return genBones
     
+    def gen_missing_bip_bones_for_ue5manny(self, inBoneArray):
+        returnBones = []
+        spine3 = None
+        neck = None
+        
+        handL = None
+        handR = None
+        
+        fingerNames = ["index", "middle", "ring", "pinky"]
+        knuckleName = "metacarpal"
+        lKnuckleDistance = []
+        rKnuckleDistance = []
+        
+        lFingers = []
+        rFingers = []
+        
+        for item in inBoneArray:
+            if rt.matchPattern(item.name, pattern="*spine 03"):
+                spine3 = item
+            if rt.matchPattern(item.name, pattern="*neck 01"):
+                neck = item
+            if rt.matchPattern(item.name, pattern="*hand*l"):
+                handL = item
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                handR = item
+            
+            for fingerName in fingerNames:
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*l"):
+                    lFingers.append(item)
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*r"):
+                    rFingers.append(item)
+            for finger in lFingers:
+                fingerDistance = rt.distance(finger, handL)
+                lKnuckleDistance.append(fingerDistance)
+            for finger in rFingers:
+                fingerDistance = rt.distance(finger, handR)
+                rKnuckleDistance.append(fingerDistance)
+        
+        filteringChar = self.name._get_filtering_char(inBoneArray[-1].name)
+        isLower = inBoneArray[-1].name[0].islower()
+        spineName = self.name.get_name_part_value_by_description("Base", "Biped") + filteringChar + "Spine"
+        
+        spine4 = self.create_nub_bone(spineName, 2)
+        spine5 = self.create_nub_bone(spineName, 2)
+        
+        spine4.name = self.name.replace_name_part("Index", spine4.name, "4")
+        spine4.name = self.name.remove_name_part("Nub", spine4.name)
+        spine5.name = self.name.replace_name_part("Index", spine5.name, "5")
+        spine5.name = self.name.remove_name_part("Nub", spine5.name)
+        if isLower:
+            spine4.name = spine4.name.lower()
+            spine5.name = spine5.name.lower()
+        
+        spineDistance = rt.distance(spine3, neck)/3.0
+        rt.setProperty(spine4, "transform", spine3.transform)
+        rt.setProperty(spine5, "transform", spine3.transform)
+        self.anim.move_local(spine4, spineDistance, 0, 0)
+        self.anim.move_local(spine5, spineDistance * 2, 0, 0)
+        
+        returnBones.append(spine4)
+        returnBones.append(spine5)
+        
+        for i, finger in enumerate(lFingers):
+            knuckleBoneName = self.name.add_suffix_to_real_name(finger.name, filteringChar+knuckleName)
+            knuckleBoneName = self.name.remove_name_part("Index", knuckleBoneName)
+            
+            knuckleBone = self.create_nub_bone(knuckleBoneName, 2)
+            knuckleBone.name = self.name.remove_name_part("Nub", knuckleBone.name)
+            if isLower:
+                knuckleBone.name = knuckleBone.name.lower()
+                
+            knuckleBone.transform = finger.transform
+            lookAtConst = self.const.assign_lookat(knuckleBone, handL)
+            lookAtConst.upnode_world = False
+            lookAtConst.pickUpNode = handL
+            lookAtConst.lookat_vector_length = 0.0
+            lookAtConst.target_axisFlip = True
+            self.const.collapse(knuckleBone)
+            self.anim.move_local(knuckleBone, -lKnuckleDistance[i]*0.8, 0, 0)
+            
+            returnBones.append(knuckleBone)
+        
+        for i, finger in enumerate(rFingers):
+            knuckleBoneName = self.name.add_suffix_to_real_name(finger.name, filteringChar+knuckleName)
+            knuckleBoneName = self.name.remove_name_part("Index", knuckleBoneName)
+            
+            knuckleBone = self.create_nub_bone(knuckleBoneName, 2)
+            knuckleBone.name = self.name.remove_name_part("Nub", knuckleBone.name)
+            if isLower:
+                knuckleBone.name = knuckleBone.name.lower()
+                
+            knuckleBone.transform = finger.transform
+            lookAtConst = self.const.assign_lookat(knuckleBone, handR)
+            lookAtConst.upnode_world = False
+            lookAtConst.pickUpNode = handR
+            lookAtConst.lookat_vector_length = 0.0
+            lookAtConst.target_axisFlip = True
+            self.const.collapse(knuckleBone)
+            self.anim.move_local(knuckleBone, -rKnuckleDistance[i]*0.8, 0, 0)
+            
+            returnBones.append(knuckleBone)
+        
+        return returnBones
+    
+    def relink_missing_bip_bones_for_ue5manny(self, inBipArray, inMissingBoneArray):
+        returnBones = []
+        
+        spine3 = None
+        
+        handL = None
+        handR = None
+        
+        knuckleName = "metacarpal"
+        
+        for item in inBipArray:
+            if rt.matchPattern(item.name, pattern="*spine 03"):
+                spine3 = item
+            if rt.matchPattern(item.name, pattern="*hand*l"):
+                handL = item
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                handR = item
+        
+        for item in inMissingBoneArray:
+            if rt.matchPattern(item.name, pattern="*spine*"):
+                item.parent = spine3
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*l"):
+                item.parent = handL
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*r"):
+                item.parent = handR
+        
+        returnBones.append(inBipArray)
+        returnBones.append(inMissingBoneArray)
+        return returnBones
+    
+    def relink_missing_skin_bones_for_ue5manny(self, inSkinArray):
+        returnBones = []
+        spine3 = None
+        spine4 = None
+        spine5 = None
+        
+        neck = None
+        clavicleL = None
+        clavicleR = None
+        
+        handL = None
+        handR = None
+        
+        fingerNames = ["index", "middle", "ring", "pinky"]
+        knuckleName = "metacarpal"
+        
+        lFingers = []
+        rFingers = []
+        
+        for item in inSkinArray:
+            if rt.matchPattern(item.name, pattern="*spine*03"):
+                spine3 = item
+            if rt.matchPattern(item.name, pattern="*neck*01"):
+                neck = item
+            if rt.matchPattern(item.name, pattern="*clavicle*l"):
+                clavicleL = item
+            if rt.matchPattern(item.name, pattern="*clavicle*r"):
+                clavicleR = item
+            
+            if rt.matchPattern(item.name, pattern="*hand*l"):
+                handL = item
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                handR = item
+            
+            for fingerName in fingerNames:
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*l"):
+                    lFingers.append(item)
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*r"):
+                    rFingers.append(item)
+        
+        for item in inSkinArray:
+            if rt.matchPattern(item.name, pattern="*spine*04"):
+                spine4 = item
+                item.parent = spine3
+            
+            if rt.matchPattern(item.name, pattern="*spine*05"):
+                spine5 = item
+                item.parent = spine4
+                neck.parent = spine5
+                clavicleL.parent = spine5
+                clavicleR.parent = spine5
+            
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*l"):
+                item.parent = handL
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*r"):
+                item.parent = handR
+                
+        filteringChar = self.name._get_filtering_char(inSkinArray[-1].name)
+        
+        for item in lFingers:
+            fingerNamePattern = self.name.add_suffix_to_real_name(item.name, filteringChar+knuckleName)
+            fingerNamePattern = self.name.remove_name_part("Index", fingerNamePattern)
+            for knuckle in inSkinArray:
+                if rt.matchPattern(knuckle.name, pattern=fingerNamePattern):
+                    item.parent = knuckle
+                    break
+        
+        for item in rFingers:
+            fingerNamePattern = self.name.add_suffix_to_real_name(item.name, filteringChar+knuckleName)
+            fingerNamePattern = self.name.remove_name_part("Index", fingerNamePattern)
+            for knuckle in inSkinArray:
+                if rt.matchPattern(knuckle.name, pattern=fingerNamePattern):
+                    item.parent = knuckle
+                    break
+        
+        return returnBones
+    
+    def create_skin_bone_from_bip_for_ue5manny(self, inBoneArray, skipNub=True, mesh=False, link=True, isHuman=False, skinBoneBaseName=""):
+        targetBones = [item for item in inBoneArray 
+                      if (rt.classOf(item) == rt.Biped_Object) 
+                      and (not rt.matchPattern(item.name, pattern="*Twist*")) 
+                      and (item != item.controller.rootNode)]
+        
+        missingBipBones = []
+        
+        if isHuman:
+            missingBipBones = self.gen_missing_bip_bones_for_ue5manny(targetBones)
+            self.relink_missing_bip_bones_for_ue5manny(targetBones, missingBipBones)
+        
+        for item in missingBipBones:
+            targetBones.append(item)
+        
+        sortedBipBones = self.sort_bones_as_hierarchy(targetBones)
+        
+        skinBones = self.create_skin_bone(sortedBipBones, skipNub=skipNub, mesh=mesh, link=False, skinBoneBaseName=skinBoneBaseName)
+        if len(skinBones) == 0:
+            return False
+        
+        for item in skinBones:
+            if rt.matchPattern(item.name, pattern="*pelvis*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*spine*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*neck*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*head*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*thigh*l"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*calf*l"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*foot*l"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*ball*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+                
+            if rt.matchPattern(item.name, pattern="*clavicle*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*upperarm*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*lowerarm*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            
+            if rt.matchPattern(item.name, pattern="*thumb*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*index*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*middle*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*ring*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*pinky*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            
+            if rt.matchPattern(item.name, 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)
+        
+        self.link_skin_bones(skinBones, sortedBipBones)
+        for item in skinBones:
+            self.anim.save_xform(item)
+        
+        return skinBones
+    
     def set_bone_on(self, inBone):
         """
         뼈대 활성화.

pyjallib/max/groinBone.py

@@ -7,7 +7,12 @@
 
 from pymxs import runtime as rt
 
-from .header import jal
+# Import necessary service classes for default initialization
+from .name import Name
+from .anim import Anim
+from .helper import Helper
+from .bone import Bone
+from .constraint import Constraint
 
 class GroinBone:
     """
@@ -15,107 +20,141 @@ class GroinBone:
     3DS Max에서 고간 부 본을 생성하고 관리하는 기능을 제공합니다.
     """
     
-    def __init__(self):
+    def __init__(self, nameService=None, animService=None, constraintService=None, boneService=None, helperService=None):
         """
         클래스 초기화.
         
         Args:
             nameService: 이름 처리 서비스 (제공되지 않으면 새로 생성)
             animService: 애니메이션 서비스 (제공되지 않으면 새로 생성)
-            constService: 제약 서비스 (제공되지 않으면 새로 생성)
-            bipService: 바이페드 서비스 (제공되지 않으면 새로 생성)
+            constraintService: 제약 서비스 (제공되지 않으면 새로 생성)
+            bipService: Biped 서비스 (제공되지 않으면 새로 생성)
+            boneService: 뼈대 서비스 (제공되지 않으면 새로 생성)
+            twistBoneService: 트위스트 본 서비스 (제공되지 않으면 새로 생성)
+            helperService: 헬퍼 객체 서비스 (제공되지 않으면 새로 생성)
         """
-        self.name = jal.name
-        self.anim = jal.anim
-        # Ensure dependent services use the potentially newly created instances
-        self.const = jal.constraint
-        self.bip = jal.bip
-        self.bone = jal.bone
-        self.twistBone = jal.twistBone
-        self.helper = jal.helper
-        
-        self.bipObj = None
-        self.genBones = []
-        self.genHelpers = []
+        # 서비스 인스턴스 설정 또는 생성
+        self.name = nameService if nameService else Name()
+        self.anim = animService if animService else Anim()
+        
+        # 종속성이 있는 서비스들은 이미 생성된 서비스들을 전달
+        self.const = constraintService if constraintService else Constraint(nameService=self.name)
+        self.bone = boneService if boneService else Bone(nameService=self.name, animService=self.anim)
+        self.helper = helperService if helperService else Helper(nameService=self.name)
+        
+        # 초기화된 결과를 저장할 변수들
+        self.pelvis = None
+        self.lThighTwist = None
+        self.rThighTwist = None
+        self.bones = []
+        self.helpers = []
+        self.pelvisWeight = 40.0
+        self.thighWeight = 60.0
     
-    def create_bone(self, inObj, inPelvisWeight=40.0, inThighWeight=60.0):
+    def reset(self):
+        """
+        클래스의 주요 컴포넌트들을 초기화합니다.
+        서비스가 아닌 클래스 자체의 작업 데이터를 초기화하는 함수입니다.
+        
+        Returns:
+            self: 메소드 체이닝을 위한 자기 자신 반환
+        """
+        self.pelvis = None
+        self.lThighTwist = None
+        self.rThighTwist = None
+        self.bones = []
+        self.helpers = []
+        self.pelvisWeight = 40.0
+        self.thighWeight = 60.0
+        
+        return self
+    
+    def create_bone(self, inPelvis, inLThighTwist, inRThighTwist, inPelvisWeight=40.0, inThighWeight=60.0):
         """
         고간 부 본을 생성하는 메소드.
         
         Args:
-            name: 생성할 본의 이름
-            parent: 부모 본 (제공되지 않으면 None)
+            inPelvis: Biped 객체
+            inPelvisWeight: 골반 가중치 (기본값: 40.0)
+            inThighWeight: 허벅지 가중치 (기본값: 60.0)
         
         Returns:
-            생성된 본 객체
+            성공 여부 (Boolean)
         """
-        if self.bip.is_biped_object(inObj) == False:
-            rt.messageBox("This is not a biped object.")
+        returnVal = {
+            "Pelvis": None,
+            "LThighTwist": None,
+            "RThighTwist": None,
+            "Bones": [],
+            "Helpers": [],
+            "PelvisWeight": inPelvisWeight,
+            "ThighWeight": inThighWeight
+        }
+        if rt.isValidNode(inPelvis) == False or rt.isValidNode(inLThighTwist) == False or rt.isValidNode(inRThighTwist) == False:
+            rt.messageBox("There is no valid node.")
             return False
         
-        bipObj = self.bip.get_com(inObj)
-        self.bipObj = bipObj
-        
-        lThigh = self.bip.get_grouped_nodes(inObj, "lLeg")[0]
-        rThigh = self.bip.get_grouped_nodes(inObj, "rLeg")[0]
-        pelvis = self.bip.get_grouped_nodes(inObj, "pelvis")[0]
+        groinName = "Groin"
+        if inPelvis.name[0].islower():
+            groinName = groinName.lower()
         
-        lThighTwists = self.twistBone.get_thigh_type(lThigh)
-        rThighTwists = self.twistBone.get_thigh_type(rThigh)
+        groinBaseName = self.name.replace_name_part("RealName", inPelvis.name, groinBaseName)
         
-        if len(lThighTwists) == 0 or len(rThighTwists) == 0:
-            rt.messageBox("There is no twist bone.")
-            return False
-        
-        pelvisHelper = self.helper.create_point(bipObj.name + " Dum Groin 00")
-        pelvisHelper.transform = bipObj.transform
-        self.anim.rotate_local(pelvisHelper, 90, 0, 0)
-        self.anim.rotate_local(pelvisHelper, 0, 0, -90)
-        pelvisHelper.parent = pelvis
+        pelvisHelperName = self.name.replace_name_part("Type", groinBaseName, self.name.get_name_part_value_by_description("Type", "Dummy"))
+        pelvisHelperName = self.name.replace_name_part("Index", pelvisHelperName, "00")
+        pelvisHelper = self.helper.create_point(pelvisHelperName)
+        pelvisHelper.transform = inPelvis.transform
+        self.anim.rotate_local(pelvisHelper, 0.0, 0.0, -180.0)
+        pelvisHelper.parent = inPelvis
         self.helper.set_shape_to_box(pelvisHelper)
-        self.genHelpers.append(pelvisHelper)
         
-        groinBones = self.bone.create_simple_bone(3.0, bipObj.name +" Groin 00", size=2)
+        lThighTwistHelperName = self.name.replace_name_part("Type", groinBaseName, self.name.get_name_part_value_by_description("Type", "Dummy"))
+        lThighTwistHelperName = self.name.replace_name_part("Side", lThighTwistHelperName, self.name.get_name_part_value_by_description("Side", "Left"))
+        lThighTwistHelperName = self.name.replace_name_part("Index", lThighTwistHelperName, "00")
+        lThighTwistHelper = self.helper.create_point(lThighTwistHelperName)
+        lThighTwistHelper.transform = pelvisHelper.transform
+        lThighTwistHelper.position = inLThighTwist.position
+        lThighTwistHelper.parent = inLThighTwist
+        self.helper.set_shape_to_box(lThighTwistHelper)
+        
+        rThighTwistHelperName = self.name.replace_name_part("Type", groinBaseName, self.name.get_name_part_value_by_description("Type", "Dummy"))
+        rThighTwistHelperName = self.name.replace_name_part("Side", rThighTwistHelperName, self.name.get_name_part_value_by_description("Side", "Right"))
+        rThighTwistHelperName = self.name.replace_name_part("Index", rThighTwistHelperName, "00")
+        rThighTwistHelper = self.helper.create_point(rThighTwistHelperName)
+        rThighTwistHelper.transform = pelvisHelper.transform
+        rThighTwistHelper.position = inRThighTwist.position
+        rThighTwistHelper.parent = inRThighTwist
+        self.helper.set_shape_to_box(rThighTwistHelper)
+        
+        groinBoneName = self.name.replace_name_part("Index", groinBaseName, "00")
+        groinBones = self.bone.create_simple_bone(3.0, groinBoneName, size=2)
         groinBones[0].transform = pelvisHelper.transform
-        groinBones[0].parent = pelvis
-        for groinBone in groinBones:
-            self.genBones.append(groinBone)
+        groinBones[0].parent = inPelvis
         
-        self.const.assign_rot_const_multi(groinBones[0], [pelvisHelper, lThigh, rThigh])
+        self.const.assign_rot_const_multi(groinBones[0], [pelvisHelper, lThighTwistHelper, rThighTwistHelper])
         rotConst = self.const.get_rot_list_controller(groinBones[0])[1]
         rotConst.setWeight(1, inPelvisWeight)
         rotConst.setWeight(2, inThighWeight/2.0)
         rotConst.setWeight(3, inThighWeight/2.0)
         
-    def delete(self):
-        """
-        생성된 고간 부 본과 헬퍼를 삭제하는 메소드.
-        
-        Returns:
-            None
-        """
-        rt.delete(self.genBones)
-        rt.delete(self.genHelpers)
-        
-        self.genBones = []
-        self.genHelpers = []
-    
-    def update_weight(self, inPelvisWeight=40.0, inThighWeight=60.0):
-        """
-        고간 부 본의 가중치를 업데이트하는 메소드.
-        
-        Args:
-            inPelvisWeight: 골반 가중치
-            inThighWeight: 허벅지 가중치
-        
-        Returns:
-            None
-        """
-        if len(self.genBones) == 0:
-            return False
-        
-        self.delete()
-        self.create_bone(self.bipObj, inPelvisWeight, inThighWeight)
-        
-        
-        
+        # 결과를 멤버 변수에 저장
+        self.pelvis = inPelvis
+        self.lThighTwist = inLThighTwist
+        self.rThighTwist = inRThighTwist
+        self.bones = groinBones
+        self.helpers = [pelvisHelper, lThighTwistHelper, rThighTwistHelper]
+        self.pelvisWeight = inPelvisWeight
+        self.thighWeight = inThighWeight
+        
+        returnVal["Pelvis"] = inPelvis
+        returnVal["LThighTwist"] = inLThighTwist
+        returnVal["RThighTwist"] = inRThighTwist
+        returnVal["Bones"] = groinBones
+        returnVal["Helpers"] = [pelvisHelper, lThighTwistHelper, rThighTwistHelper]
+        returnVal["PelvisWeight"] = inPelvisWeight
+        returnVal["ThighWeight"] = inThighWeight
+        
+        # 메소드 호출 후 데이터 초기화
+        self.reset()
+        
+        return returnVal