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

pyjallib/__init__.py

@@ -6,12 +6,12 @@ pyjallib Package
 Python library for game character development pipeline.
 """
 
-__version__ = '0.1.10'
+__version__ = '0.1.12'
 
 # reload_modules 함수를 패키지 레벨에서 사용 가능하게 함
-from .namePart import NamePart, NamePartType
-from .naming import Naming
-from .namingConfig import NamingConfig
-from .nameToPath import NameToPath
-from .perforce import Perforce
-from .reloadModules import reload_modules
+from pyjallib.namePart import NamePart, NamePartType
+from pyjallib.naming import Naming
+from pyjallib.namingConfig import NamingConfig
+from pyjallib.nameToPath import NameToPath
+from pyjallib.perforce import Perforce
+from pyjallib.reloadModules import reload_modules

pyjallib/max/__init__.py

@@ -7,37 +7,35 @@ JalTools 3DS 패키지
 """
 
 # 모듈 임포트
-from .header import Header
+from pyjallib.max.header import Header
 
-from .name import Name
-from .anim import Anim
+from pyjallib.max.name import Name
+from pyjallib.max.anim import Anim
 
-from .helper import Helper
-from .constraint import Constraint
-from .bone import Bone
+from pyjallib.max.helper import Helper
+from pyjallib.max.constraint import Constraint
+from pyjallib.max.bone import Bone
 
-from .mirror import Mirror
-from .layer import Layer
-from .align import Align
-from .select import Select
-from .link import Link
+from pyjallib.max.mirror import Mirror
+from pyjallib.max.layer import Layer
+from pyjallib.max.align import Align
+from pyjallib.max.select import Select
+from pyjallib.max.link import Link
 
-from .bip import Bip
-from .skin import Skin
-from .morph import Morph
+from pyjallib.max.bip import Bip
+from pyjallib.max.skin import Skin
+from pyjallib.max.morph import Morph
 
-from .twistBone import TwistBone
-from .twistBoneChain import TwistBoneChain
-from .groinBone import GroinBone
-from .groinBoneChain import GroinBoneChain
-from .autoClavicle import AutoClavicle
-from .autoClavicleChain import AutoClavicleChain
-from .volumeBone import VolumeBone
-from .volumeBoneChain import VolumeBoneChain
-from .kneeBone import KneeBone
-from .hip import Hip
+from pyjallib.max.boneChain import BoneChain
 
-from .ui.Container import Container
+from pyjallib.max.twistBone import TwistBone
+from pyjallib.max.groinBone import GroinBone
+from pyjallib.max.autoClavicle import AutoClavicle
+from pyjallib.max.volumeBone import VolumeBone
+from pyjallib.max.kneeBone import KneeBone
+from pyjallib.max.hip import Hip
+
+from pyjallib.max.ui.Container import Container
 
 # 모듈 내보내기
 __all__ = [
@@ -55,6 +53,7 @@ __all__ = [
     'Bip',
     'Skin',
     'Morph',
+    'BoneChain',
     'TwistBone',
     'TwistBoneChain',
     'GroinBone',

pyjallib/max/autoClavicle.py

@@ -16,6 +16,8 @@ from .bone import Bone
 from .constraint import Constraint
 from .bip import Bip
 
+from .boneChain import BoneChain
+
 
 class AutoClavicle:
     """
@@ -166,12 +168,45 @@ class AutoClavicle:
         result = {
             "Bones": genBones,
             "Helpers": genHelpers,
-            "Clavicle": inClavicle,
-            "UpperArm": inUpperArm,
-            "LiftScale": liftScale
+            "SourceBones": [inClavicle, inUpperArm],
+            "Parameters": [liftScale]
         }
         
         # 메소드 호출 후 데이터 초기화
         self.reset()
         
-        return result
+        return BoneChain.from_result(result)
+    
+    def create_bones_from_chain(self, inBoneChain: BoneChain):
+        """
+        기존 BoneChain 객체에서 자동 쇄골 뼈를 생성합니다.
+        기존 설정을 복원하거나 저장된 데이터에서 쇄골 셋업을 재생성할 때 사용합니다.
+        
+        Args:
+            inBoneChain (BoneChain): 자동 쇄골 정보를 포함한 BoneChain 객체
+        
+        Returns:
+            BoneChain: 업데이트된 BoneChain 객체 또는 실패 시 None
+        """
+        if not inBoneChain or inBoneChain.is_empty():
+            return None
+        
+        inBoneChain.delete()
+            
+        # BoneChain에서 필요한 정보 추출
+        sourceBones = inBoneChain.sourceBones
+        parameters = inBoneChain.parameters
+        
+        # 필수 소스 본 확인
+        if len(sourceBones) < 2 or not rt.isValidNode(sourceBones[0]) or not rt.isValidNode(sourceBones[1]):
+            return None
+            
+        # 파라미터 가져오기 (또는 기본값 사용)
+        liftScale = parameters[0] if len(parameters) > 0 else 0.8
+        
+        # 쇄골 생성
+        inClavicle = sourceBones[0]
+        inUpperArm = sourceBones[1]
+        
+        # 새로운 쇄골 생성
+        return self.create_bones(inClavicle, inUpperArm, liftScale)

pyjallib/max/bip.py

@@ -439,6 +439,71 @@ class Bip:
             if colNum > 0:
                 rt.biped.deleteAllCopyCollections(inBipRoot.controller)
     
+    def collapse_layers(self, inBipRoot):
+        """
+        Biped 레이어 병합
+        
+        Args:
+            inBipRoot: 대상 Biped 객체
+        """
+        if not self.is_biped_object(inBipRoot):
+            return False
+        
+        layerNum = rt.biped.numLayers(inBipRoot.controller)
+        while layerNum > 0:
+            rt.biped.collapseAtLayer(inBipRoot.controller, 0)
+            layerNum = rt.biped.numLayers(inBipRoot.controller)
+    
+    def save_bip_file(self, inBipRoot, inFile, inBakeAllKeys=True, inCollapseLayers=True, progress_callback=None):
+        """
+        Biped BIP 파일 저장
+        
+        Args:
+            inBipRoot: 저장 대상 Biped 루트 노드
+            inFile: 저장할 BIP 파일 경로
+            inBakeAllKeys: 모든 키를 베이크할지 여부 (기본값: True)
+            inCollapseLayers: 레이어를 병합할지 여부 (기본값: True)
+            
+        Returns:
+            bool: 저장 성공 시 True, 실패 시 False
+        """
+        if not self.is_biped_object(inBipRoot):
+            return False
+        
+        directory = os.path.dirname(inFile)
+        if directory and not os.path.exists(directory):
+            try:
+                os.makedirs(directory, exist_ok=True)
+            except OSError as e:
+                return False
+        
+        if inCollapseLayers:
+            self.collapse_layers(inBipRoot)
+        
+        if inBakeAllKeys:
+            allTargetBipedObjs = self.get_nodes(inBipRoot)
+            startFrame = rt.execute("(animationRange.start as integer) / TicksPerFrame")
+            endFrame = rt.execute("(animationRange.end as integer) / TicksPerFrame")
+            totalFrame = endFrame - startFrame + 1
+            
+            for frame in range(startFrame, endFrame + 1):
+                for item in allTargetBipedObjs:
+                    if item == item.controller.rootNode:
+                        horizontalController = rt.getPropertyController(item.controller, "horizontal")
+                        verticalController = rt.getPropertyController(item.controller, "vertical")
+                        turningController = rt.getPropertyController(item.controller, "turning")
+                        
+                        rt.biped.addNewKey(horizontalController, frame)
+                        rt.biped.addNewKey(verticalController, frame)
+                        rt.biped.addNewKey(turningController, frame)
+                    else:
+                        rt.biped.addNewKey(item.controller, frame)
+                if progress_callback:
+                    progress_callback(frame - startFrame + 1, totalFrame)
+        
+        rt.biped.saveBipFile(inBipRoot.controller, inFile)
+        return True
+    
     def link_base_skeleton(self, skinBoneBaseName="b"):
         """
         기본 스켈레톤 링크 (Biped와 일반 뼈대 연결)
@@ -608,6 +673,7 @@ class Bip:
         for i, fingers in enumerate(lFingersList):
             for j, item in enumerate(fingers):
                 item.name = self.name.replace_name_part("RealName", item.name, fingerName[i])
+                item.name = self.name.replace_name_part("Side", item.name, self.name.get_name_part_value_by_description("Side", "Left"))
                 item.name = self.name.replace_name_part("Index", item.name, str(j+1))
             
             fingerNub = self.bone.get_every_children(fingers[-1])[0]
@@ -618,6 +684,7 @@ class Bip:
         for i, fingers in enumerate(rFingersList):
             for j, item in enumerate(fingers):
                 item.name = self.name.replace_name_part("RealName", item.name, fingerName[i])
+                item.name = self.name.replace_name_part("Side", item.name, self.name.get_name_part_value_by_description("Side", "Right"))
                 item.name = self.name.replace_name_part("Index", item.name, str(j+1))
             
             fingerNub = self.bone.get_every_children(fingers[-1])[0]
@@ -688,8 +755,8 @@ class Bip:
             toeNub.name = self.name.replace_name_part("Nub", toeNub.name, self.name.get_name_part_value_by_description("Nub", "Nub"))
             
             if toeLinkNum == 1:
-                rToesList[0][0].name = self.name.replace_name_part("RealName", lToesList[0][0].name, "ball")
-                rToesList[0][0].name = self.name.remove_name_part("Index", lToesList[0][0].name)
+                rToesList[0][0].name = self.name.replace_name_part("RealName", rToesList[0][0].name, "ball")
+                rToesList[0][0].name = self.name.remove_name_part("Index", rToesList[0][0].name)
             else:
                 for i, item in enumerate(rToesList[0]):
                     item.name = self.name.replace_name_part("RealName", item.name, "ball")

pyjallib/max/bone.py

@@ -239,6 +239,7 @@ class Bone:
         nubBone.backfin = False
         nubBone.sidefins = False
         nubBone.name = self.name.remove_name_part("Index", inName)
+        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"))
         
         # 화면 갱신 재개
@@ -888,6 +889,7 @@ class Bone:
         returnBones = []
         spine3 = None
         neck = None
+        head = None
         
         handL = None
         handR = None
@@ -905,6 +907,8 @@ class Bone:
                 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"):
@@ -924,6 +928,8 @@ class Bone:
         
         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)
@@ -946,6 +952,23 @@ class Bone:
         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)
@@ -992,6 +1015,7 @@ class Bone:
         returnBones = []
         
         spine3 = None
+        neck = None
         
         handL = None
         handR = None
@@ -1001,6 +1025,8 @@ class Bone:
         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"):
@@ -1009,6 +1035,8 @@ class Bone:
         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"):
@@ -1025,6 +1053,8 @@ class Bone:
         spine5 = None
         
         neck = None
+        neck2 = None
+        head = None
         clavicleL = None
         clavicleR = None
         
@@ -1042,6 +1072,8 @@ class Bone:
                 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"):
@@ -1069,6 +1101,11 @@ class Bone:
                 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

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