pyjallib 0.1.17__py3-none-any.whl → 0.1.20__py3-none-any.whl

pyjallib/max/macro/jal_macro_bone.py

@@ -47,8 +47,8 @@ class BoneNameDialog(QtWidgets.QDialog):
         side_group = QtWidgets.QGroupBox("Side:")
         side_layout = QtWidgets.QVBoxLayout()
         self.side_none_radio = QtWidgets.QRadioButton("(None)")
-        self.side_l_radio = QtWidgets.QRadioButton("L")
-        self.side_r_radio = QtWidgets.QRadioButton("R")
+        self.side_l_radio = QtWidgets.QRadioButton(jal.name.get_name_part("Side").get_value_by_description("Left"))
+        self.side_r_radio = QtWidgets.QRadioButton(jal.name.get_name_part("Side").get_value_by_description("Right"))
         self.side_none_radio.setChecked(True)
         side_layout.addWidget(self.side_none_radio)
         side_layout.addWidget(self.side_l_radio)
@@ -59,8 +59,8 @@ class BoneNameDialog(QtWidgets.QDialog):
         front_group = QtWidgets.QGroupBox("Front:")
         front_layout = QtWidgets.QVBoxLayout()
         self.front_none_radio = QtWidgets.QRadioButton("(None)")
-        self.front_f_radio = QtWidgets.QRadioButton("F")
-        self.front_b_radio = QtWidgets.QRadioButton("B")
+        self.front_f_radio = QtWidgets.QRadioButton(jal.name.get_name_part("FrontBack").get_value_by_description("Forward"))
+        self.front_b_radio = QtWidgets.QRadioButton(jal.name.get_name_part("FrontBack").get_value_by_description("Backward"))
         self.front_none_radio.setChecked(True)
         front_layout.addWidget(self.front_none_radio)
         front_layout.addWidget(self.front_f_radio)
@@ -136,16 +136,16 @@ class BoneNameDialog(QtWidgets.QDialog):
         if self.side_none_radio.isChecked():
             self.sideName = ""
         elif self.side_l_radio.isChecked():
-            self.sideName = "L"
+            self.sideName = jal.name.get_name_part("Side").get_value_by_description("Left")
         elif self.side_r_radio.isChecked():
-            self.sideName = "R"
+            self.sideName = jal.name.get_name_part("Side").get_value_by_description("Right")
         
         if self.front_none_radio.isChecked():
             self.frontBackName = ""
         elif self.front_f_radio.isChecked():
-            self.frontBackName = "F"
+            self.frontBackName = jal.name.get_name_part("FrontBack").get_value_by_description("Forward")
         elif self.front_b_radio.isChecked():
-            self.frontBackName = "B"
+            self.frontBackName = jal.name.get_name_part("FrontBack").get_value_by_description("Backward")
         
         RealName = self.name_edit.text() if self.name_edit.text() != "" else "TempBone"
         
@@ -189,6 +189,190 @@ class BoneNameDialog(QtWidgets.QDialog):
         self.boneNameSetted = False
         self.reject()
 
+class BoneSizeDialog(QtWidgets.QDialog):
+    def __init__(self, parent=QtWidgets.QWidget.find(rt.windows.getMAXHWND())):
+        super().__init__(parent)
+        self.setWindowTitle("Bone Size")
+        self.setMinimumWidth(300)
+        
+        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
+        
+        # UI 변수들 초기화
+        self.fin_on = True
+        self.fin_size = 2.0
+        self.bone_size = 4.0
+        self.bone_taper = 90.0
+        
+        # 원래 본 모양 저장용 변수들
+        self.original_bone_shapes = {}  # {본객체: 원래모양배열}
+        self.original_selection = []    # 원래 선택된 본들
+        
+        # Layouts
+        main_layout = QtWidgets.QVBoxLayout(self)
+        fin_layout = QtWidgets.QHBoxLayout()
+        bone_layout = QtWidgets.QHBoxLayout()
+        button_layout = QtWidgets.QHBoxLayout()
+        
+        # Fin On 체크박스와 Fin Size 스피너 (가로로 배치)
+        self.fin_on_checkbox = QtWidgets.QCheckBox("Fin On")
+        self.fin_on_checkbox.setChecked(self.fin_on)
+        fin_layout.addWidget(self.fin_on_checkbox)
+        
+        fin_layout.addWidget(QtWidgets.QLabel("Fin Size:"))
+        
+        self.fin_size_spinner = QtWidgets.QDoubleSpinBox()
+        self.fin_size_spinner.setRange(0.0, 100.0)
+        self.fin_size_spinner.setValue(self.fin_size)
+        self.fin_size_spinner.setDecimals(1)
+        self.fin_size_spinner.setSingleStep(0.1)
+        fin_layout.addWidget(self.fin_size_spinner)
+        
+        # Bone Size와 Bone Taper 스피너 (가로로 배치)
+        bone_layout.addWidget(QtWidgets.QLabel("Bone Size:"))
+        
+        self.bone_size_spinner = QtWidgets.QDoubleSpinBox()
+        self.bone_size_spinner.setRange(0.0, 100.0)
+        self.bone_size_spinner.setValue(self.bone_size)
+        self.bone_size_spinner.setDecimals(1)
+        self.bone_size_spinner.setSingleStep(0.1)
+        bone_layout.addWidget(self.bone_size_spinner)
+        
+        bone_layout.addWidget(QtWidgets.QLabel("Bone Taper:"))
+        
+        self.bone_taper_spinner = QtWidgets.QDoubleSpinBox()
+        self.bone_taper_spinner.setRange(0.0, 100.0)
+        self.bone_taper_spinner.setValue(self.bone_taper)
+        self.bone_taper_spinner.setDecimals(1)
+        self.bone_taper_spinner.setSingleStep(0.1)
+        bone_layout.addWidget(self.bone_taper_spinner)
+        
+        # OK/Cancel Buttons
+        self.ok_button = QtWidgets.QPushButton("OK")
+        self.cancel_button = QtWidgets.QPushButton("Cancel")
+        
+        # Arrange Buttons
+        button_layout.addStretch()
+        button_layout.addWidget(self.ok_button)
+        button_layout.addWidget(self.cancel_button)
+        
+        # Add layouts to main layout
+        main_layout.addLayout(fin_layout)
+        main_layout.addLayout(bone_layout)
+        main_layout.addStretch()
+        main_layout.addLayout(button_layout)
+        
+        # Connect signals
+        self.ok_button.clicked.connect(self.ok_clicked)
+        self.cancel_button.clicked.connect(self.cancel_clicked)
+        
+        # Connect all relevant UI changes to the update method
+        self.fin_on_checkbox.toggled.connect(self.update_ui)
+        self.fin_size_spinner.valueChanged.connect(self.update_ui)
+        self.bone_size_spinner.valueChanged.connect(self.update_ui)
+        self.bone_taper_spinner.valueChanged.connect(self.update_ui)
+        
+        # 초기 선택된 본들의 원래 모양 저장
+        self.save_original_bone_shapes()
+        
+        self.update_ui()  # Initial update
+        
+    def save_original_bone_shapes(self):
+        """선택된 본들의 원래 모양을 저장합니다."""
+        selObjs = rt.getCurrentSelection()
+        for item in selObjs:
+            if rt.classOf(item) == rt.BoneGeometry:
+                self.original_selection.append(item)
+                self.original_bone_shapes[item] = jal.bone.get_bone_shape(item)
+    
+    def restore_original_bone_shapes(self):
+        """저장된 원래 모양으로 본들을 되돌립니다."""
+        for item, shape_array in self.original_bone_shapes.items():
+            if rt.isValidObj(item):
+                jal.bone.pasete_bone_shape(item, shape_array)
+        rt.redrawViews()
+        
+    def update_ui(self):
+        """UI 값들을 업데이트합니다."""
+        self.fin_on = self.fin_on_checkbox.isChecked()
+        self.fin_size = self.fin_size_spinner.value()
+        self.bone_size = self.bone_size_spinner.value()
+        self.bone_taper = self.bone_taper_spinner.value()
+        
+        # Fin On 상태에 따라 Fin Size 스피너 활성화/비활성화
+        self.fin_size_spinner.setEnabled(self.fin_on)
+        
+        selObjs = rt.getCurrentSelection()
+        for item in selObjs:
+            if self.fin_on:
+                jal.bone.set_fin_on(item, inSize=self.fin_size)
+            else:
+                jal.bone.set_fin_off(item)
+            jal.bone.set_bone_size(item, self.bone_size)
+            jal.bone.set_bone_taper(item, self.bone_taper)
+        
+        rt.redrawViews()
+        
+    def ok_clicked(self):
+        """OK 버튼 클릭 처리"""
+        self.update_ui()
+        self.accept()
+    
+    def cancel_clicked(self):
+        """Cancel 버튼 클릭 처리"""
+        # 원래 모양으로 되돌리기
+        self.restore_original_bone_shapes()
+        self.reject()
+
+class TurnBoneDialog(QtWidgets.QDialog):
+    def __init__(self, parent=QtWidgets.QWidget.find(rt.windows.getMAXHWND())):
+        super().__init__(parent)
+        self.setWindowTitle("Turn Bone")
+        self.setMinimumWidth(300)
+        self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
+
+        # 다이얼로그 크기 고정 (예: 220x80)
+        self.setFixedSize(220, 80)
+
+        # 메인 레이아웃 생성
+        main_layout = QtWidgets.QVBoxLayout(self)
+
+        # 버튼 레이아웃 (가로)
+        button_layout = QtWidgets.QHBoxLayout()
+
+        # 90, 45, 5 버튼 생성 및 크기 설정
+        self.btn_90 = QtWidgets.QPushButton("90")
+        self.btn_45 = QtWidgets.QPushButton("45")
+        self.btn_5 = QtWidgets.QPushButton("5")
+        for btn in [self.btn_90, self.btn_45, self.btn_5]:
+            btn.setMinimumWidth(50)
+            btn.setMaximumWidth(50)
+            btn.setMinimumHeight(20)
+            btn.setMaximumHeight(20)
+            button_layout.addWidget(btn)
+
+        # 버튼 레이아웃을 메인 레이아웃에 추가
+        main_layout.addLayout(button_layout)
+
+        # 버튼 클릭 이벤트 연결
+        self.btn_90.clicked.connect(lambda: self.turn_bone_by_angle(90))
+        self.btn_45.clicked.connect(lambda: self.turn_bone_by_angle(45))
+        self.btn_5.clicked.connect(lambda: self.turn_bone_by_angle(5))
+
+    def turn_bone_by_angle(self, inAngle):
+        # Ctrl 키가 눌려 있으면 각도를 음수로 변환
+        modifiers = QtWidgets.QApplication.keyboardModifiers()
+        if modifiers & QtCore.Qt.ControlModifier:
+            angle = -inAngle
+        else:
+            angle = inAngle
+        selObjs = rt.getCurrentSelection()
+        for item in selObjs:
+            if rt.classOf(item) == rt.BoneGeometry:
+                jal.bone.turn_bone(item, angle)
+        
+        rt.redrawViews()
+
+
 def jal_bone_on():
     jal.bone.set_bone_on_selection()
 
@@ -275,6 +459,17 @@ def jal_bone_nub_create():
     else:
         jal.bone.create_nub_bone("Temp", 2)
 
+def jal_bone_size_modify():
+    dialog = BoneSizeDialog()
+    dialog.show()
+    
+    # 다이얼로그가 닫힐 때까지 대기하지 않고 즉시 반환
+    # 사용자가 다이얼로그를 닫으면 자동으로 정리됨
+
+def jal_bone_turn():
+    dialog = TurnBoneDialog()
+    dialog.show()
+
 # Register macroscripts
 macroScript_Category = "jalTools"
 
@@ -358,3 +553,21 @@ rt.macros.new(
     "Bone Nub Create",
     "jal_bone_nub_create()"
 )
+
+rt.jal_bone_size_modify = jal_bone_size_modify
+rt.macros.new(
+    macroScript_Category,
+    "jal_boneSizeModify",
+    "Bone Size Modify",
+    "Bone Size Modify",
+    "jal_bone_size_modify()"
+)
+
+rt.jal_bone_turn = jal_bone_turn
+rt.macros.new(
+    macroScript_Category,
+    "jal_boneTurn",
+    "Bone Turn",
+    "Bone Turn",
+    "jal_bone_turn()"
+)

pyjallib/max/macro/jal_macro_constraint.py

@@ -11,6 +11,12 @@ def jal_collapse_const():
         for selObj in selArray:
             jal.constraint.collapse(selObj)
 
+def jal_collapse_const_with_tcb_rot():
+    if rt.selection.count > 0:
+        selArray = rt.getCurrentSelection()
+        for selObj in selArray:
+            jal.constraint.collapse(selObj, inUseTCBRot=True)
+
 def jal_pos_const():
     if rt.selection.count > 1:
         selArray = rt.getCurrentSelection()
@@ -35,6 +41,12 @@ def jal_ori_const():
         
         jal.constraint.assign_rot_const_multi(oriObj, targetObjArray)
 
+def jal_tcb_rot():
+    if rt.selection.count > 1:
+        selArray = rt.getCurrentSelection()
+        for item in selArray:
+            jal.constraint.assign_tcb_rot(item)
+
 def jal_rot_script_const():
     if rt.selection.count == 2:
         selArray = rt.getCurrentSelection()
@@ -87,6 +99,15 @@ rt.macros.new(
     "jal_collapse_const()"
 )
 
+rt.jal_collapse_const_with_tcb_rot = jal_collapse_const_with_tcb_rot
+rt.macros.new(
+    macroScript_Category,
+    "jal_collapse_const_with_tcb_rot",
+    "Collapse Constraints with TCB Rot",
+    "Collapse Constraints with TCB Rot",
+    "jal_collapse_const_with_tcb_rot()"
+)
+
 rt.jal_pos_const = jal_pos_const
 rt.macros.new(
     macroScript_Category,
@@ -105,6 +126,15 @@ rt.macros.new(
     "jal_ori_const()"
 )
 
+rt.jal_tcb_rot = jal_tcb_rot
+rt.macros.new(
+    macroScript_Category,
+    "jal_tcb_rot",
+    "Constraint TCB Rot",
+    "Constraint TCB Rot",
+    "jal_tcb_rot()"
+)
+
 rt.jal_rot_script_const = jal_rot_script_const
 rt.macros.new(
     macroScript_Category,

pyjallib/max/mirror.py

@@ -251,18 +251,17 @@ class Mirror:
         elif mAxis == 3:
             axisFactor = [1, 1, -1]  # z축 미러링
         
-        # 새 뼈대와 부모 정보 저장 배열 준비
-        parents = []
+        # 새 뼈대와 원본-미러 매핑 정보 저장
         created = []
+        bone_mapping = {}  # 원본 뼈대 -> 미러 뼈대 매핑
         
         # 시작점 위치 (미러링 중심) 설정
         root = bones[0].transform.translation
         
-        # 정렬된 뼈대 순서대로 처리
+        # 정렬된 뼈대 순서대로 처리 (실제 뼈대만)
         for i in range(len(bones)):
             original = bones[i]
-            if rt.classOf(original) != rt.BoneGeometry:  # 실제 뼈대가 아닌 경우
-                parents.append(None)  # 부모 없음 표시
+            if rt.classOf(original) != rt.BoneGeometry:  # 실제 뼈대가 아닌 경우 건너뛰기
                 continue
             
             # 원본 뼈대의 시작점, 끝점, Z축 방향 가져오기
@@ -310,16 +309,24 @@ class Mirror:
             reflection.wirecolor = original.wirecolor
             
             created.append(reflection)
-            parents.append(reflection)
+            bone_mapping[original] = reflection
         
         # 계층 구조 연결 (자식부터 상위로)
-        for i in range(len(created)-1, 0, -1):
-            pIndex = bones.index(bones[i].parent) if bones[i].parent in bones else 0
-            if pIndex != 0:
-                created[i].parent = parents[pIndex]
-        
-        # 루트 뼈대의 부모 설정
-        created[0].parent = bones[0].parent
+        for i in range(len(created)-1, -1, -1):  # 인덱스 len(created)-1부터 0까지 역순으로 처리
+            original_bone = None
+            # 원본 뼈대 찾기
+            for orig, mirror in bone_mapping.items():
+                if mirror == created[i]:
+                    original_bone = orig
+                    break
+            
+            if original_bone and original_bone.parent:
+                # 부모가 매핑에 있는지 확인
+                if original_bone.parent in bone_mapping:
+                    created[i].parent = bone_mapping[original_bone.parent]
+                else:
+                    # 부모가 미러링된 뼈대 중에 없으면 원본 부모 사용
+                    created[i].parent = original_bone.parent
         
         # 부모가 없는 뼈대는 위치 조정
         for i in range(len(created)):

pyjallib/max/shoulder.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+어깨 모듈
+자동으로 어깨 본을 생성.
+"""
+
+from pymxs import runtime as rt
+
+# 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
+from .bip import Bip
+
+from .boneChain import BoneChain
+
+class Shoulder:
+    def __init__(self, nameService=None, animService=None, helperService=None, boneService=None, constraintService=None, bipService=None):
+        self.name = nameService if nameService else Name()
+        self.anim = animService if animService else Anim()
+        self.helper = helperService if helperService else Helper(nameService=self.name)
+        self.bone = boneService if boneService else Bone(nameService=self.name, animService=self.anim)
+        self.const = constraintService if constraintService else Constraint(nameService=self.name)
+        self.bip = bipService if bipService else Bip(nameService=self.name, animService=self.anim)
+        
+        self.boneSize = 2.0
+        
+        self.genBones = []
+        self.genHelpers = []
+        self.clavicle = None
+        self.upperArm = None
+        self.autoClavicle = None
+        self.upperArmTwist = None
+        self.twistWeight = 0.7
+        
+        self.shoulderLookAtTargetPosConstExpression = ""
+        self.shoulderLookAtTargetPosConstExpression += "local clavicleDistance = distance clavicle upperArm\n"
+        self.shoulderLookAtTargetPosConstExpression += "local xPos = clavicleDistance * distanceDir\n"
+        self.shoulderLookAtTargetPosConstExpression += "[xPos, 0.0, 0.0]\n"
+    
+    def reset(self):
+        self.genBones = []
+        self.genHelpers = []
+        self.clavicle = None
+        self.upperArm = None
+        self.autoClavicle = None
+        self.upperArmTwist = None
+        self.twistWeight = 0.7
+        
+        return self
+    
+    def create_bones(self, inClavicle, inUpperArm, inAutoClavicle, inUpperArmTwist, inTwistWeight=0.7):
+        if not rt.isValidNode(inClavicle) or not rt.isValidNode(inUpperArm) or not rt.isValidNode(inAutoClavicle) or not rt.isValidNode(inUpperArmTwist):
+            return False
+        
+        clavicleLength = rt.distance(inClavicle, inUpperArm)
+        facingDirVec = inUpperArm.transform.position - inClavicle.transform.position
+        inObjXAxisVec = inClavicle.objectTransform.row1
+        distanceDir = 1.0 if rt.dot(inObjXAxisVec, facingDirVec) > 0 else -1.0
+        clavicleLength *= distanceDir
+        
+        genBones = []
+        genHelpers = []
+        
+        # 자동 쇄골 이름 생성 및 뼈대 생성
+        shoulderName = self.name.replace_name_part("RealName", inClavicle.name, "Shoulder")
+        if inClavicle.name[0].islower():
+            shoulderName = shoulderName.lower()
+            
+        shoulderBone = self.bone.create_nub_bone(shoulderName, self.boneSize)
+        shoulderBone.name = self.name.remove_name_part("Nub", shoulderBone.name)
+        shoulderBone.transform = inUpperArm.transform
+        shoulderBone.parent = inAutoClavicle
+        genBones.append(shoulderBone)
+        
+        # 어깨 타겟 포인트 생성
+        shoulderLookAtTarget = self.helper.create_point(self.name.replace_name_part("Type", shoulderName, self.name.get_name_part_value_by_description("Type", "Target")))
+        shoulderLookAtTarget.transform = inUpperArm.transform
+        shoulderLookAtTarget.parent = inUpperArm
+        shoulderLookAtTargetPosConst = self.const.assign_pos_script_controller(shoulderLookAtTarget)
+        shoulderLookAtTargetPosConst.addConstant("distanceDir", distanceDir)
+        shoulderLookAtTargetPosConst.addNode("clavicle", inClavicle)
+        shoulderLookAtTargetPosConst.addNode("upperArm", inUpperArm)
+        shoulderLookAtTargetPosConst.setExpression(self.shoulderLookAtTargetPosConstExpression)
+        genHelpers.append(shoulderLookAtTarget)
+        
+        # 어깨 회전 헬퍼 포인트 생성
+        shoulderLookAtHelper = self.helper.create_point(self.name.replace_name_part("Type", shoulderName, self.name.get_name_part_value_by_description("Type", "LookAt")))
+        shoulderLookAtHelper.transform = inClavicle.transform
+        shoulderLookAtHelper.parent = inClavicle
+        shoulderLookAtHelperPosConst = self.const.assign_pos_const(shoulderLookAtHelper, inClavicle)
+        
+        lookAtConst = self.const.assign_lookat(shoulderLookAtHelper, shoulderLookAtTarget)
+        lookAtConst.upnode_world = False
+        lookAtConst.pickUpNode = inClavicle
+        lookAtConst.lookat_vector_length = 0.0
+        if distanceDir < 0:
+            lookAtConst.target_axisFlip = True
+        genHelpers.append(shoulderLookAtHelper)
+        
+        # 어깨 최종 회전 헬퍼 포인트 생성
+        shoulderRotHelper = self.helper.create_point(self.name.replace_name_part("Type", shoulderName, self.name.get_name_part_value_by_description("Type", "Rotation")))
+        shoulderRotHelper.transform = inUpperArm.transform
+        shoulderRotHelper.parent = inUpperArm
+        shoulderRotHelperPosConst = self.const.assign_pos_const(shoulderRotHelper, inUpperArm)
+        
+        shoulderRotHelperRotConst = self.const.assign_rot_const_multi(shoulderRotHelper, [shoulderLookAtHelper, inUpperArmTwist])
+        shoulderRotHelperRotConst.setWeight(1, 100.0-inTwistWeight)
+        shoulderRotHelperRotConst.setWeight(2, inTwistWeight)
+        genHelpers.append(shoulderRotHelper)
+        
+        # 어깨 최종 회전 오프셋 헬퍼 포인트 생성
+        shoulderRotOffsetHelepr = self.helper.create_point(self.name.replace_name_part("Type", shoulderName, self.name.get_name_part_value_by_description("Type", "Dummy")))
+        shoulderRotOffsetHelepr.transform = inUpperArm.transform
+        shoulderRotOffsetHelepr.parent = shoulderRotHelper
+        genHelpers.append(shoulderRotOffsetHelepr)
+        
+        # 어깨 본 회전 설정
+        shoulderBoneRotConst = self.const.assign_rot_const(shoulderBone, shoulderRotOffsetHelepr)
+        
+        self.genBones = genBones
+        self.genHelpers = genHelpers
+        self.clavicle = inClavicle
+        self.upperArm = inUpperArm
+        self.autoClavicle = inAutoClavicle
+        self.upperArmTwist = inUpperArmTwist
+        self.twistWeight = inTwistWeight
+        
+        result = {
+            "Bones": genBones,
+            "Helpers": genHelpers,
+            "SourceBones": [inClavicle, inUpperArm, inAutoClavicle, inUpperArmTwist],
+            "Parameters": [inTwistWeight]
+        }
+        
+        self.reset()
+        
+        rt.redrawViews()
+        
+        return BoneChain.from_result(result)
+    
+    def create_bones_from_chain(self, inBoneChain: BoneChain):
+        if not inBoneChain or inBoneChain.is_empty():
+            return None
+        
+        inBoneChain.delete()
+        
+        # BoneChain에서 필요한 정보 추출
+        sourceBones = inBoneChain.sourceBones
+        parameters = inBoneChain.parameters
+        
+        # 필수 소스 본 확인
+        if len(sourceBones) < 4 or not rt.isValidNode(sourceBones[0]) or not rt.isValidNode(sourceBones[1]) or not rt.isValidNode(sourceBones[2]) or not rt.isValidNode(sourceBones[3]):
+            return None
+            
+        # 파라미터 가져오기 (또는 기본값 사용)
+        twistWeight = parameters[0] if len(parameters) > 0 else 0.7
+        
+        # 쇄골 생성
+        inClavicle = sourceBones[0]
+        inUpperArm = sourceBones[1]
+        inAutoClavicle = sourceBones[2]
+        inUpperArmTwist = sourceBones[3]
+        
+        # 새로운 쇄골 생성
+        return self.create_bones(inClavicle, inUpperArm, inAutoClavicle, inUpperArmTwist, twistWeight)
+    
+    
+        

pyjallib/max/toolManager.py

@@ -10,11 +10,23 @@ from PySide2 import QtWidgets, QtCore
 import gc
 
 class ToolManager:
+    """
+    3DS Max에서 실행되는 도구(툴) 인스턴스를 통합 관리하는 클래스입니다.
+    도구의 등록, 닫기, 표시 등 라이프사이클을 관리합니다.
+    """
     def __init__(self):
+        """
+        ToolManager 인스턴스를 초기화합니다.
+        """
         self.tools = {}  # {tool_class_name: [instances]} 형태로 관리
     
     def register_tool(self, tool_instance):
-        """도구 인스턴스를 등록합니다"""
+        """
+        도구 인스턴스를 등록합니다.
+
+        Args:
+            tool_instance: 등록할 도구 인스턴스
+        """
         class_name = tool_instance.__class__.__name__
         
         if class_name not in self.tools:
@@ -23,7 +35,12 @@ class ToolManager:
         self.tools[class_name].append(tool_instance)
     
     def close_tool_by_type(self, tool_class):
-        """특정 유형의 도구를 모두 닫습니다"""
+        """
+        특정 클래스의 모든 도구 인스턴스를 닫고 정리합니다.
+
+        Args:
+            tool_class: 닫을 도구의 클래스
+        """
         class_name = tool_class.__name__
         
         if class_name not in self.tools:
@@ -66,13 +83,12 @@ class ToolManager:
     def show_tool(self, tool_class, **kwargs):
         """
         도구를 표시합니다. 중복 실행을 방지하고 항상 새 인스턴스를 생성합니다.
-        
+
         Args:
-            tool_class: 도구 클래스
+            tool_class: 표시할 도구 클래스
             **kwargs: 도구 클래스 생성자에 전달할 인자들
-            
         Returns:
-            새로 생성된 도구 인스턴스
+            object: 새로 생성된 도구 인스턴스
         """
         # 기존 인스턴스 모두 정리
         self.close_tool_by_type(tool_class)