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

pyjallib/max/volumeBoneChain.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+볼륨 뼈대 체인(Volume Bone Chain) 모듈 - 3ds Max 캐릭터 리깅을 위한 볼륨 본 시스템
+
+이 모듈은 VolumeBone 클래스가 생성한 볼륨 본 세트를 관리하고 제어하는 기능을 제공합니다.
+관절 회전 시 부피 감소를 방지하기 위한 보조 본 시스템으로, 특히 캐릭터 팔다리나 
+관절 부위의 자연스러운 움직임을 구현하는 데 유용합니다.
+
+Examples:
+    # 기본 볼륨 체인 생성 예시
+    from pyjallib.max import VolumeBone, VolumeBoneChain
+    from pymxs import runtime as rt
+    
+    # 캐릭터에서 팔꿈치 뼈대와 상위 부모 가져오기
+    elbow_bone = rt.getNodeByName("L_Elbow_Bone")
+    upper_arm = rt.getNodeByName("L_UpperArm_Bone")
+    
+    # VolumeBone 클래스 인스턴스 생성
+    volume_bone = VolumeBone()
+    
+    # 다양한 옵션으로 볼륨 뼈대 생성
+    volume_result = volume_bone.create_bones(
+        elbow_bone,                   # 관절 본
+        upper_arm,                    # 관절 부모
+        inRotScale=0.7,               # 회전 영향도 (0.0 ~ 1.0)
+        inVolumeSize=10.0,            # 볼륨 크기
+        inRotAxises=["X", "Z"],       # 회전 감지 축 (여러 축 지정 가능)
+        inTransAxises=["PosY", "PosZ"], # 이동 방향 축
+        inTransScales=[1.0, 0.8]      # 각 방향별 이동 스케일
+    )
+    
+    # 생성된 뼈대로 VolumeBoneChain 인스턴스 생성
+    chain = VolumeBoneChain.from_volume_bone_result(volume_result)
+    
+    # 체인 속성 및 관리 기능 사용
+    print(f"볼륨 크기: {chain.get_volume_size()}")
+    print(f"볼륨 본 개수: {len(chain.bones)}")
+    
+    # 볼륨 속성 동적 업데이트
+    chain.update_volume_size(15.0)    # 볼륨 크기 변경
+    chain.update_rot_scale(0.5)       # 회전 영향도 변경
+    
+    # 회전 축 업데이트
+    chain.update_rot_axises(["Y", "Z"])
+    
+    # 이동 축 업데이트
+    chain.update_trans_axises(["PosX", "PosZ"])
+    
+    # 이동 스케일 업데이트
+    chain.update_trans_scales([0.7, 1.2])
+    
+    # 필요 없어지면 체인의 모든 뼈대 삭제
+    # chain.delete_all()
+"""
+
+import copy
+
+from pymxs import runtime as rt
+from pyjallib.max.header import get_pyjallibmaxheader
+jal = get_pyjallibmaxheader()
+
+class VolumeBoneChain:
+    """
+    볼륨 본 체인 관리 클래스
+    
+    VolumeBone 클래스로 생성된 볼륨 본들의 집합을 관리하는 클래스입니다.
+    볼륨 본의 크기 조절, 회전 및 이동 축 변경, 스케일 조정 등의 기능을 제공하며,
+    여러 개의 볼륨 본을 하나의 논리적 체인으로 관리합니다.
+    생성된 볼륨 본 체인은 캐릭터 관절의 자연스러운 변형을 위해 사용됩니다.
+    """
+    
+    def __init__(self, inResult):
+        """
+        볼륨 본 체인 클래스 초기화
+        
+        VolumeBone 클래스의 create_bones 메서드로부터 생성된 결과 딕셔너리를 
+        받아 볼륨 본 체인을 구성합니다.
+        
+        Args:
+            inResult: VolumeBone 클래스의 create_bones 메서드가 반환한 결과 딕셔너리
+                      (루트 본, 회전 헬퍼, 회전 축, 이동 축, 볼륨 크기 등의 정보 포함)
+        """
+        self.rootBone = inResult.get("RootBone", None)
+        self.rotHelper = inResult.get("RotHelper", None)
+        self.rotScale = inResult.get("RotScale", 0.0)
+        self.limb = inResult.get("Limb", None)
+        self.limbParent = inResult.get("LimbParent", None)
+        self.bones = inResult.get("Bones", [])
+        self.rotAxises = inResult.get("RotAxises", [])
+        self.transAxises = inResult.get("TransAxises", [])
+        self.transScales = inResult.get("TransScales", [])
+        self.volumeSize = inResult.get("VolumeSize", 0.0)
+    
+    def get_volume_size(self):
+        """
+        볼륨 뼈대의 크기 가져오기
+        
+        볼륨 본 생성 시 설정된 크기 값을 반환합니다. 이 값은 관절의 볼륨감 정도를
+        결정합니다.
+        
+        Returns:
+            float: 현재 설정된 볼륨 크기 값
+        """
+        return self.volumeSize
+    
+    def is_empty(self):
+        """
+        체인이 비어있는지 확인
+        
+        볼륨 본 체인에 본이 하나라도 존재하는지 확인합니다.
+        
+        Returns:
+            bool: 체인이 비어있으면 True, 하나 이상의 본이 있으면 False
+        """
+        return len(self.bones) == 0
+    
+    def clear(self):
+        """체인의 모든 뼈대 및 헬퍼 참조 제거"""
+        self.rootBone = None
+        self.rotHelper = None
+        self.rotScale = 0.0
+        self.limb = None
+        self.limbParent = None
+        self.bones = []
+        self.rotAxises = []
+        self.transAxises = []
+        self.transScales = []
+        self.volumeSize = 0.0
+    
+    def delete_all(self):
+        """
+        체인의 모든 뼈대와 헬퍼를 3ds Max 씬에서 삭제
+        
+        Returns:
+            삭제 성공 여부 (boolean)
+        """
+        if self.is_empty():
+            return False
+            
+        try:
+            # 루트 본 삭제
+            if self.rootBone:
+                rt.delete(self.rootBone)
+            
+            # 회전 헬퍼 삭제
+            if self.rotHelper:
+                rt.delete(self.rotHelper)
+                
+            # 뼈대 삭제
+            for bone in self.bones:
+                rt.delete(bone)
+                                
+            self.rotAxises = []
+            self.transAxises = []
+            self.transScales = []    
+                
+            self.clear()
+            return True
+        except:
+            return False
+    
+    def update_volume_size(self, inNewSize):
+        """
+        볼륨 뼈대의 크기 업데이트
+        
+        Args:
+            inNewSize: 새로운 볼륨 크기 값
+            
+        Returns:
+            업데이트 성공 여부 (boolean)
+        """
+        if self.is_empty() or self.limb is None:
+            return False
+            
+        try:
+            # 필요한 값들 백업
+            limb = self.limb
+            limbParent = self.limbParent 
+            rotScale = self.rotScale
+            rotAxises = copy.deepcopy(self.rotAxises)
+            transAxises = copy.deepcopy(self.transAxises)
+            transScales = copy.deepcopy(self.transScales)
+            
+            self.delete_all()
+            # VolumeBone 클래스를 통해 새로운 볼륨 뼈대 생성
+            result = jal.volumeBone.create_bones(limb, limbParent, inVolumeSize=inNewSize, 
+                                                 inRotScale=rotScale, inRotAxises=rotAxises, 
+                                                 inTransAxises=transAxises, inTransScales=transScales)
+            
+            # 속성들 한번에 업데이트
+            for key, value in result.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+            
+            self.volumeSize = inNewSize
+            
+            return True
+        except:
+            return False
+    
+    def update_rot_axises(self, inNewRotAxises):
+        """
+        볼륨 뼈대의 회전 축을 업데이트
+    
+        Args:
+            inNewRotAxises: 새로운 회전 축 리스트
+        
+        Returns:
+            업데이트 성공 여부 (boolean)
+        """
+        if self.is_empty() or self.limb is None:
+            return False
+        
+        try:
+            # 필요한 값들 백업
+            limb = self.limb
+            limbParent = self.limbParent 
+            rotScale = self.rotScale
+            volumeSize = self.volumeSize
+            transAxises = copy.deepcopy(self.transAxises)
+            transScales = copy.deepcopy(self.transScales)
+            
+            self.delete_all()
+            # VolumeBone 클래스를 통해 새로운 볼륨 뼈대 생성
+            result = jal.volumeBone.create_bones(limb, limbParent, inVolumeSize=volumeSize, 
+                                                inRotScale=rotScale, inRotAxises=inNewRotAxises, 
+                                                inTransAxises=transAxises, inTransScales=transScales)
+            
+            # 속성들 한번에 업데이트
+            for key, value in result.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+            
+            return True
+        except:
+            return False
+
+    def update_trans_axises(self, inNewTransAxises):
+        """
+        볼륨 뼈대의 이동 축을 업데이트
+    
+        Args:
+            inNewTransAxises: 새로운 이동 축 리스트
+        
+        Returns:
+            업데이트 성공 여부 (boolean)
+        """
+        if self.is_empty() or self.limb is None:
+            return False
+        
+        try:
+            # 필요한 값들 백업
+            limb = self.limb
+            limbParent = self.limbParent 
+            rotScale = self.rotScale
+            volumeSize = self.volumeSize
+            rotAxises = copy.deepcopy(self.rotAxises)
+            transScales = copy.deepcopy(self.transScales)
+            
+            self.delete_all()
+            # VolumeBone 클래스를 통해 새로운 볼륨 뼈대 생성
+            result = jal.volumeBone.create_bones(limb, limbParent, inVolumeSize=volumeSize, 
+                                                inRotScale=rotScale, inRotAxises=rotAxises, 
+                                                inTransAxises=inNewTransAxises, inTransScales=transScales)
+            
+            # 속성들 한번에 업데이트
+            for key, value in result.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+            
+            return True
+        except:
+            return False
+
+    def update_trans_scales(self, inNewTransScales):
+        """
+        볼륨 뼈대의 이동 스케일을 업데이트
+    
+        Args:
+            inNewTransScales: 새로운 이동 스케일 리스트
+        
+        Returns:
+            업데이트 성공 여부 (boolean)
+        """
+        if self.is_empty() or self.limb is None:
+            return False
+        
+        try:
+            # 필요한 값들 백업
+            limb = self.limb
+            limbParent = self.limbParent 
+            rotScale = self.rotScale
+            volumeSize = self.volumeSize
+            rotAxises = copy.deepcopy(self.rotAxises)
+            transAxises = copy.deepcopy(self.transAxises)
+            
+            self.delete_all()
+            # VolumeBone 클래스를 통해 새로운 볼륨 뼈대 생성
+            result = jal.volumeBone.create_bones(limb, limbParent, inVolumeSize=volumeSize, 
+                                                inRotScale=rotScale, inRotAxises=rotAxises, 
+                                                inTransAxises=transAxises, inTransScales=inNewTransScales)
+            
+            # 속성들 한번에 업데이트
+            for key, value in result.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+            
+            return True
+        except:
+            return False
+    
+    def update_rot_scale(self, inNewRotScale):
+        """
+        볼륨 뼈대의 회전 스케일을 업데이트
+    
+        Args:
+            inNewRotScale: 새로운 회전 스케일 값
+        
+        Returns:
+            업데이트 성공 여부 (boolean)
+        """
+        if self.is_empty() or self.limb is None:
+            return False
+        
+        try:
+            # 필요한 값들 백업
+            limb = self.limb
+            limbParent = self.limbParent 
+            volumeSize = self.volumeSize
+            rotAxises = copy.deepcopy(self.rotAxises)
+            transAxises = copy.deepcopy(self.transAxises)
+            transScales = copy.deepcopy(self.transScales)
+            
+            self.delete_all()
+            # VolumeBone 클래스를 통해 새로운 볼륨 뼈대 생성
+            result = jal.volumeBone.create_bones(limb, limbParent, inVolumeSize=volumeSize, 
+                                                inRotScale=inNewRotScale, inRotAxises=rotAxises, 
+                                                inTransAxises=transAxises, inTransScales=transScales)
+            
+            # 속성들 한번에 업데이트
+            for key, value in result.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+        
+            return True
+        except:
+            return False
+    
+    @classmethod
+    def from_volume_bone_result(cls, inResult):
+        """
+        VolumeBone 클래스의 결과로부터 VolumeBoneChain 인스턴스 생성
+        
+        Args:
+            inResult: VolumeBone 클래스의 메서드가 반환한 결과 딕셔너리
+            
+        Returns:
+            VolumeBoneChain 인스턴스
+        """
+        chain = cls(inResult)
+        return chain

pyjallib/namePart.py

@@ -69,13 +69,13 @@ class NamePart:
     
     def _initialize_type_defaults(self):
         """타입에 따른 기본 설정을 초기화합니다."""
-        if self._type == NamePartType.INDEX:
+        if self._type.value == NamePartType.INDEX.value:
             # Index 타입은 숫자만 처리하므로 predefined values는 사용하지 않음
             self._predefinedValues = []
             self._descriptions = []
             self._koreanDescriptions = [] # Clear korean descriptions
             self._weights = []
-        elif self._type == NamePartType.REALNAME:
+        elif self._type.value == NamePartType.REALNAME.value:
             # RealName 타입은 predefined values를 사용하지 않음
             self._predefinedValues = []
             self._descriptions = []
@@ -88,7 +88,7 @@ class NamePart:
         값들은 5부터 시작해서 5씩 증가하는 가중치를 갖습니다.
         """
         # REALNAME이나 INDEX 타입인 경우 weights를 사용하지 않음
-        if self._type == NamePartType.REALNAME or self._type == NamePartType.INDEX:
+        if self._type.value == NamePartType.REALNAME.value or self._type.value == NamePartType.INDEX.value:
             self._weights = []
             return
             
@@ -144,8 +144,8 @@ class NamePart:
         Returns:
             PREFIX 타입이면 True, 아니면 False
         """
-        return self._type == NamePartType.PREFIX
-    
+        return self._type.value == NamePartType.PREFIX.value
+
     def is_suffix(self):
         """
         이름 부분이 SUFFIX 타입인지 확인합니다.
@@ -153,8 +153,8 @@ class NamePart:
         Returns:
             SUFFIX 타입이면 True, 아니면 False
         """
-        return self._type == NamePartType.SUFFIX
-    
+        return self._type.value == NamePartType.SUFFIX.value
+
     def is_realname(self):
         """
         이름 부분이 REALNAME 타입인지 확인합니다.
@@ -162,8 +162,8 @@ class NamePart:
         Returns:
             REALNAME 타입이면 True, 아니면 False
         """
-        return self._type == NamePartType.REALNAME
-    
+        return self._type.value == NamePartType.REALNAME.value
+
     def is_index(self):
         """
         이름 부분이 INDEX 타입인지 확인합니다.
@@ -171,7 +171,7 @@ class NamePart:
         Returns:
             INDEX 타입이면 True, 아니면 False
         """
-        return self._type == NamePartType.INDEX
+        return self._type.value == NamePartType.INDEX.value
     
     def add_predefined_value(self, inValue, inDescription="", inKoreanDescription=""):
         """
@@ -186,7 +186,7 @@ class NamePart:
             추가 성공 여부 (이미 존재하는 경우 False)
         """
         # REALNAME이나 INDEX 타입인 경우 predefined values를 사용하지 않음
-        if self._type == NamePartType.REALNAME or self._type == NamePartType.INDEX:
+        if self._type.value == NamePartType.REALNAME.value or self._type.value == NamePartType.INDEX.value:
             return False
             
         if inValue not in self._predefinedValues:
@@ -228,9 +228,9 @@ class NamePart:
             inKoreanDescriptions: 설정할 값들의 한국어 설명 목록 (기본값: None, 빈 문자열로 초기화)
         """
         # REALNAME이나 INDEX 타입인 경우 predefined values를 사용하지 않음
-        if self._type == NamePartType.REALNAME or self._type == NamePartType.INDEX:
+        if self._type.value == NamePartType.REALNAME.value or self._type.value == NamePartType.INDEX.value:
             return
-            
+        
         self._predefinedValues = inValues.copy() if inValues else []
         
         # 설명 세팅
@@ -399,15 +399,15 @@ class NamePart:
             유효하면 True, 아니면 False
         """
         # INDEX 타입은 숫자 문자열만 유효
-        if self._type == NamePartType.INDEX:
+        if self._type.value == NamePartType.INDEX.value:
             return isinstance(inValue, str) and inValue.isdigit()
             
         # PREFIX와 SUFFIX 타입은 predefined values 중 하나여야 함
-        if (self._type == NamePartType.PREFIX or self._type == NamePartType.SUFFIX) and self._predefinedValues:
+        if (self._type.value == NamePartType.PREFIX.value or self._type.value == NamePartType.SUFFIX.value) and self._predefinedValues:
             return inValue in self._predefinedValues
             
         # REALNAME 타입은 모든 문자열 유효
-        if self._type == NamePartType.REALNAME:
+        if self._type.value == NamePartType.REALNAME.value:
             return isinstance(inValue, str)
             
         # 정의되지 않은 타입이면 기존 동작대로 처리

pyjallib/nameToPath.py

@@ -101,7 +101,7 @@ class NameToPath(Naming):
         for key, value in nameDict.items():
             namePart = self.sourceNaming.get_name_part(key)
             if self.get_name_part(namePart.get_name()):
-                if namePart.get_type() == NamePartType.REALNAME:
+                if namePart.get_type().value == NamePartType.REALNAME.value:
                     # 실제 이름인 경우, 해당 이름을 사용
                     pathDict[key] = value
                 else:

pyjallib/naming.py

@@ -325,7 +325,7 @@ class Naming:
             
         partValues = partObj.get_predefined_values()
         
-        if partType == NamePartType.PREFIX or partType == NamePartType.SUFFIX:
+        if partType.value == NamePartType.PREFIX.value or partType.value == NamePartType.SUFFIX.value:
             return any(item in inStr for item in partValues)
         
         return False
@@ -351,7 +351,7 @@ class Naming:
             
         partValues = partObj.get_predefined_values()
         
-        if partType == NamePartType.PREFIX or partType == NamePartType.SUFFIX:
+        if partType.value == NamePartType.PREFIX.value or partType.value == NamePartType.SUFFIX.value:
             try:
                 foundIndex = partObj._descriptions.index(inDescription)
                 return partValues[foundIndex]
@@ -371,24 +371,24 @@ class Naming:
         partType = partObj.get_type()
         if not partType:
             return returnStr
-            
+        
         partValues = partObj.get_predefined_values()
-        if partType != NamePartType.INDEX and partType != NamePartType.REALNAME and not partValues:
+        if partType.value != NamePartType.INDEX.value and partType.value != NamePartType.REALNAME.value and not partValues:
             return returnStr
         
-        if partType == NamePartType.PREFIX:
+        if partType.value == NamePartType.PREFIX.value:
             for item in nameArray:
                 if item in partValues:
                     returnStr = item
                     break
         
-        if partType == NamePartType.SUFFIX:
+        if partType.value == NamePartType.SUFFIX.value:
             for i in range(len(nameArray) - 1, -1, -1):
                 if nameArray[i] in partValues:
                     returnStr = nameArray[i]
                     break
-                
-        if partType == NamePartType.INDEX:
+        
+        if partType.value == NamePartType.INDEX.value:
             if self.get_name_part_index("Index") > self.get_name_part_index("RealName"):
                 for i in range(len(nameArray) - 1, -1, -1):
                     if nameArray[i].isdigit():
@@ -399,7 +399,6 @@ class Naming:
                     if item.isdigit():
                         returnStr = item
                         break
-        
         return returnStr
         
     def get_name(self, inNamePartName, inStr):
@@ -424,7 +423,7 @@ class Naming:
         partIndex = self.get_name_part_index(inNamePartName)
         foundIndex = nameArray.index(foundName)
         
-        if partType == NamePartType.PREFIX:
+        if partType.value == NamePartType.PREFIX.value:
             if foundIndex >= 0:
                 prevNameParts = self._nameParts[:partIndex]
                 prevNames = [self.pick_name(part.get_name(), inStr) for part in prevNameParts]
@@ -434,8 +433,8 @@ class Naming:
                         prevNamesInNameArray.remove(prevName)
                 if len(prevNamesInNameArray) == 0 :
                     returnStr = foundName
-        
-        if partType == NamePartType.SUFFIX:
+    
+        if partType.value == NamePartType.SUFFIX.value:
             if foundIndex >= 0:
                 nextNameParts = self._nameParts[partIndex + 1:]
                 nextNames = [self.pick_name(part.get_name(), inStr) for part in nextNameParts]
@@ -445,8 +444,8 @@ class Naming:
                         nextNamesInNameArray.remove(nextName)
                 if len(nextNamesInNameArray) == 0 :
                     returnStr = foundName
-        
-        if partType == NamePartType.INDEX:
+    
+        if partType.value == NamePartType.INDEX.value:
             returnStr = self.pick_name(inNamePartName, inStr)
                 
         return returnStr
@@ -946,13 +945,13 @@ class Naming:
         for part in self._nameParts:
             partName = part.get_name()
             partType = part.get_type()
-            if (partType != NamePartType.REALNAME or partType != NamePartType.INDEX) and part.is_direction():
+            if (partType.value != NamePartType.REALNAME.value and partType.value != NamePartType.INDEX.value) and part.is_direction():
                 partIndex = self.get_name_part_index(partName)
                 foundName = self.get_name(partName, inStr)
                 opositeName = part.get_most_different_weight_value(foundName)
                 if opositeName and foundName != opositeName:
                     nameArray[partIndex] = opositeName
-        
+    
         returnName = self._combine(nameArray, self._get_filtering_char(inStr))
         
         return returnName

pyjallib/namingConfig.py

@@ -104,7 +104,7 @@ class NamingConfig:
             RealName 파트의 인덱스, 없으면 -1
         """
         for i, part in enumerate(self.name_parts):
-            if part.get_type() == NamePartType.REALNAME:
+            if part.get_type().value == NamePartType.REALNAME.value:
                 return i
         return -1
     
@@ -325,12 +325,12 @@ class NamingConfig:
             return False
         
         # 필수 RealName 부분은 항상 REALNAME 타입이어야 함
-        if part_name == "RealName" and part_type != NamePartType.REALNAME:
+        if part_name == "RealName" and part_type.value != NamePartType.REALNAME.value:
             print("오류: RealName 부분은 반드시 REALNAME 타입이어야 합니다.")
             return False
         
         # Index 부분은 항상 INDEX 타입이어야 함
-        if part_name == "Index" and part_type != NamePartType.INDEX:
+        if part_name == "Index" and part_type.value != NamePartType.INDEX.value:
             print("오류: Index 부분은 반드시 INDEX 타입이어야 합니다.")
             return False