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

pyjallib/max/bone.py

@@ -239,7 +239,8 @@ 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.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"))
         
         # 화면 갱신 재개
         rt.enableSceneRedraw()
@@ -679,18 +680,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 +706,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 +771,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 +801,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 +839,7 @@ class Bone:
             skipNub: Nub 뼈대 건너뛰기 (기본값: True)
             mesh: 메시 스냅샷 사용 (기본값: False)
             link: 원본 뼈대에 연결 (기본값: True)
-            skinBoneBaseName: 스킨 뼈대 기본 이름 (기본값: "b")
+            skinBoneBaseName: 스킨 뼈대 기본 이름 (기본값: "")
             
         Returns:
             생성된 스킨 뼈대 배열
@@ -844,6 +885,327 @@ class Bone:
         
         return genBones
     
+    def gen_missing_bip_bones_for_ue5manny(self, inBoneArray):
+        returnBones = []
+        spine3 = None
+        neck = None
+        head = 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="*head"):
+                head = 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()
+        
+        # Spine 4,5 생성
+        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)
+        
+        # 목 생성
+        neckName = self.name.get_name_part_value_by_description("Base", "Biped") + filteringChar + "Neck"
+        
+        nekc2 = self.create_nub_bone(neckName, 2)
+        
+        nekc2.name = self.name.replace_name_part("Index", nekc2.name, "2")
+        nekc2.name = self.name.remove_name_part("Nub", nekc2.name)
+        if isLower:
+            nekc2.name = nekc2.name.lower()
+        
+        neckDistance = rt.distance(neck, head)/2.0
+        rt.setProperty(nekc2, "transform", neck.transform)
+        self.anim.move_local(nekc2, neckDistance, 0, 0)
+        
+        returnBones.append(nekc2)
+        
+        # 손가락용 메타카팔 생성
+        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
+        neck = 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="*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 item in inMissingBoneArray:
+            if rt.matchPattern(item.name, pattern="*spine*"):
+                item.parent = spine3
+            if rt.matchPattern(item.name, pattern="*neck*"):
+                item.parent = neck
+            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
+        neck2 = None
+        head = 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="*head*"):
+                head = 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="*neck*02"):
+                neck2 = item
+                item.parent = neck
+                head.parent = neck2
+            
+            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/boneChain.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+뼈대 체인(Bone Chain) 기본 클래스 - 뼈대 체인 관리를 위한 공통 기능 제공
+
+이 모듈은 다양한 뼈대 체인 클래스의 기본 부모 클래스로 사용됩니다.
+AutoClavicleChain, GroinBoneChain, VolumeBoneChain, TwistBoneChain 등의
+특수 목적 뼈대 체인들이 상속받아 사용하며, 공통된 관리 기능을 제공합니다.
+
+기본 클래스는 다음과 같은 공통 기능을 제공합니다:
+- 체인의 뼈대 및 헬퍼 관리
+- 체인 비우기/삭제 기능
+- 체인 상태 확인 기능
+"""
+
+from pymxs import runtime as rt
+
+
+class BoneChain:
+    """
+    뼈대 체인을 관리하는 기본 클래스
+    
+    다양한 뼈대 체인의 공통 기능을 담당하는 부모 클래스입니다.
+    뼈대와 헬퍼를 저장하고 기본적인 조작 기능을 제공합니다.
+    """
+    
+    def __init__(self, inResult=None):
+        """
+        클래스 초기화
+        
+        Args:
+            inResult (dict, optional): 뼈대 생성 결과 데이터를 담은 딕셔너리. 기본값은 None
+        """
+        # 기본 속성 초기화
+        if inResult is None:
+            # inResult가 None이면 속성들을 빈 리스트로 초기화
+            self.bones = []
+            self.helpers = []
+            self.result = {}  # 빈 딕셔너리로 초기화
+            self.sourceBones = []
+            self.parameters = []
+        else:
+            self.bones = inResult.get("Bones", [])
+            self.helpers = inResult.get("Helpers", [])
+            self.result = inResult  # 원본 결과 보존
+            self.sourceBones = inResult.get("SourceBones", [])
+            self.parameters = inResult.get("Parameters", [])
+        
+    def is_empty(self):
+        """
+        체인이 비어있는지 확인
+        
+        Returns:
+            bool: 체인이 비어있으면 True, 아니면 False
+        """
+        return len(self.bones) == 0
+    
+    def clear(self):
+        """체인의 모든 뼈대와 헬퍼 참조 제거"""
+        self.bones = []
+        self.helpers = []
+        self.sourceBones = []
+        self.parameters = []
+        
+    def delete(self):
+        """
+        체인의 모든 뼈대와 헬퍼를 3ds Max 씬에서 삭제
+        
+        Returns:
+            bool: 삭제 성공 여부
+        """
+        if self.is_empty() and not self.helpers:
+            return False
+            
+        try:
+            # 뼈대 삭제
+            if self.bones:
+                for bone in self.bones:
+                    if rt.isValidNode(bone):
+                        rt.delete(bone)
+            
+            # 헬퍼 삭제
+            if self.helpers:
+                for helper in self.helpers:
+                    if rt.isValidNode(helper):
+                        rt.delete(helper)
+            
+            self.bones = []
+            self.helpers = []
+            
+            return True
+        except:
+            return False
+    
+    def delete_all(self):
+        """
+        체인의 모든 뼈대와 헬퍼를 3ds Max 씬에서 삭제
+        
+        Returns:
+            bool: 삭제 성공 여부
+        """
+        if self.is_empty() and not self.helpers:
+            return False
+            
+        try:
+            # 뼈대 삭제
+            if self.bones:
+                for bone in self.bones:
+                    if rt.isValidNode(bone):
+                        rt.delete(bone)
+            
+            # 헬퍼 삭제
+            if self.helpers:
+                for helper in self.helpers:
+                    if rt.isValidNode(helper):
+                        rt.delete(helper)
+                
+            self.clear()
+            return True
+        except:
+            return False
+    
+    def get_bones(self):
+        """
+        체인의 모든 뼈대 가져오기
+        
+        Returns:
+            list: 모든 뼈대 객체의 배열
+        """
+        if self.is_empty():
+            return []
+        
+        return self.bones
+    
+    def get_helpers(self):
+        """
+        체인의 모든 헬퍼 가져오기
+        
+        Returns:
+            list: 모든 헬퍼 객체의 배열
+        """
+        if not self.helpers:
+            return []
+        
+        return self.helpers
+    
+    @classmethod
+    def from_result(cls, inResult):
+        """
+        결과 딕셔너리로부터 체인 인스턴스 생성
+        
+        Args:
+            inResult (dict): 뼈대 생성 결과를 담은 딕셔너리
+            
+        Returns:
+            BoneChain: 생성된 체인 인스턴스
+        """
+        return cls(inResult)
+    
+    def update_from_result(self, inResult):
+        """
+        기존 체인 인스턴스를 결과 딕셔너리로부터 업데이트
+        
+        이미 생성된 체인 객체의 내용을 새로운 결과 데이터로 갱신합니다.
+        
+        Args:
+            inResult (dict): 뼈대 생성 결과를 담은 딕셔너리
+            
+        Returns:
+            self: 메서드 체이닝을 위한 자기 자신 반환
+        """
+        if inResult is None:
+            return self
+            
+        self.bones = inResult.get("Bones", [])
+        self.helpers = inResult.get("Helpers", [])
+        self.result = inResult  # 원본 결과 보존
+        self.sourceBones = inResult.get("SourceBones", [])
+        self.parameters = inResult.get("Parameters", [])
+        
+        return self