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

pyjallib/__init__.py

@@ -6,7 +6,7 @@ pyjallib Package
 Python library for game character development pipeline.
 """
 
-__version__ = '0.1.6'
+__version__ = '0.1.8'
 
 # reload_modules 함수를 패키지 레벨에서 사용 가능하게 함
 from .namePart import NamePart, NamePartType

pyjallib/max/ConfigFiles/3DSMaxNamingConfig.json

@@ -34,8 +34,8 @@
         {
             "name": "Type",
             "predefinedValues": [
-                "P",
                 "Dum",
+                "P",
                 "Exp",
                 "IK",
                 "T",
@@ -57,8 +57,8 @@
             ],
             "type": "PREFIX",
             "descriptions": [
-                "Parent",
                 "Dummy",
+                "Parent",
                 "ExposeTM",
                 "IK",
                 "Target",

pyjallib/max/__init__.py

@@ -24,10 +24,14 @@ from .link import Link
 
 from .bip import Bip
 from .skin import Skin
+from .morph import Morph
 
 from .twistBone import TwistBone
 from .groinBone import GroinBone
 from .autoClavicle import AutoClavicle
+from .volumePreserveBone import VolumePreserveBone
+
+from .ui.Container import Container
 
 # 모듈 내보내기
 __all__ = [
@@ -44,7 +48,10 @@ __all__ = [
     'Link',
     'Bip',
     'Skin',
+    'Morph',
     'TwistBone',
     'GroinBone',
-    'AutoClavicle'
+    'AutoClavicle',
+    'VolumePreserveBone',
+    'Container'
 ]

pyjallib/max/autoClavicle.py

@@ -120,3 +120,50 @@ class AutoClavicle:
         ikGoal.parent = autoClavicleRotHelper
         
         return autoClavicleBones
+    
+    def get_bones(self, inClavicle, inUpperArm):
+        """
+        자동 쇄골 뼈를 가져옵니다.
+        
+        Args:
+            inClavicle: 쇄골 뼈 객체
+            inUpperArm: 상완 뼈 객체
+            
+        Returns:
+            자동 쇄골 뼈대 배열
+        """
+        clavicleChildren = [item for item in self.bone.get_every_children(inClavicle) if rt.classOf(item) == rt.BoneGeometry]
+        upperArmChildren = [item for item in self.bone.get_every_children(inUpperArm) if rt.classOf(item) == rt.BoneGeometry]
+        returnVal = []
+        for item in clavicleChildren:
+            if item not in returnVal:
+                returnVal.append(item)
+        for item in upperArmChildren:
+            if item not in returnVal:
+                returnVal.append(item)
+        
+        return returnVal
+    
+    def get_helpers(self, inClavicle, inUpperArm):
+        """
+        자동 쇄골 헬퍼를 가져옵니다.
+        
+        Args:
+            inClavicle: 쇄골 뼈 객체
+            inUpperArm: 상완 뼈 객체
+            
+        Returns:
+            자동 쇄골 헬퍼 배열
+        """
+        clavicleChildren = [item for item in self.bone.get_every_children(inClavicle) if rt.classOf(item) == rt.Point]
+        upperArmChildren = [item for item in self.bone.get_every_children(inUpperArm) if rt.classOf(item) == rt.Point]
+        returnVal = []
+        for item in clavicleChildren:
+            if item not in returnVal:
+                returnVal.append(item)
+        for item in upperArmChildren:
+            if item not in returnVal:
+                returnVal.append(item)
+        
+        return returnVal
+        

pyjallib/max/constraint.py

@@ -212,6 +212,8 @@ class Constraint:
         """
         for item in inTargetArray:
             self.assign_pos_const(inObj, item, keepInit=keepInit)
+        
+        return self.get_pos_const(inObj)
     
     def add_target_to_pos_const(self, inObj, inTarget, inWeight):
         """
@@ -251,8 +253,36 @@ class Constraint:
         posList = self.assign_pos_list(inObj)
         
         # Position_XYZ 컨트롤러 할당
-        rt.setPropertyController(posList, "Available", rt.Position_XYZ())
+        posXYZ = rt.Position_XYZ()
+        rt.setPropertyController(posList, "Available", posXYZ)
+        posList.setActive(posList.count)
+        
+        return posXYZ
+    
+    def assign_pos_script_controller(self, inObj):
+        """
+        객체에 스크립트 기반 위치 컨트롤러를 할당.
+        
+        Args:
+            inObj: 컨트롤러를 할당할 객체
+            
+        Returns:
+            None
+        """
+        # 위치 컨트롤러가 리스트 형태가 아니면 변환
+        pos_controller = rt.getPropertyController(inObj.controller, "Position")
+        if rt.classOf(pos_controller) != rt.Position_list:
+            rt.setPropertyController(inObj.controller, "Position", rt.Position_list())
+            
+        # 위치 리스트 컨트롤러 가져오기
+        posList = self.assign_pos_list(inObj)
+        
+        # 스크립트 기반 위치 컨트롤러 할당
+        scriptPos = rt.Position_Script()
+        rt.setPropertyController(posList, "Available", scriptPos)
         posList.setActive(posList.count)
+        
+        return scriptPos
     
     def get_rot_list_controller(self, inObj):
         """
@@ -392,6 +422,8 @@ class Constraint:
         """
         for item in inTargetArray:
             self.assign_rot_const(inObj, item, keepInit=keepInit)
+        
+        return self.get_rot_const(inObj)
     
     def add_target_to_rot_const(self, inObj, inTarget, inWeight):
         """
@@ -431,8 +463,11 @@ class Constraint:
         rotList = self.assign_rot_list(inObj)
         
         # Euler_XYZ 컨트롤러 할당
-        rt.setPropertyController(rotList, "Available", rt.Euler_XYZ())
+        eulerXYZ = rt.Euler_XYZ()
+        rt.setPropertyController(rotList, "Available", eulerXYZ)
         rotList.setActive(rotList.count)
+        
+        return eulerXYZ
     
     def get_lookat(self, inObj):
         """
@@ -528,6 +563,8 @@ class Constraint:
         """
         for item in inTargetArray:
             self.assign_lookat(inObj, item, keepInit=keepInit)
+        
+        return self.get_lookat(inObj)
     
     def assign_lookat_flipless(self, inObj, inTarget):
         """

pyjallib/max/header.py

@@ -27,6 +27,9 @@ from .skin import Skin
 from .twistBone import TwistBone
 from .groinBone import GroinBone
 from .autoClavicle import AutoClavicle
+from .volumePreserveBone import VolumePreserveBone
+
+from .morph import Morph
 
 class Header:
     """
@@ -68,6 +71,11 @@ class Header:
         self.twistBone = TwistBone(nameService=self.name, animService=self.anim, constService=self.constraint, bipService=self.bip, boneService=self.bone)
         self.groinBone = GroinBone(nameService=self.name, animService=self.anim, helperService=self.helper, constService=self.constraint, bipService=self.bip, boneService=self.bone, twistBoneService=self.twistBone)
         self.autoClavicle = AutoClavicle(nameService=self.name, animService=self.anim, helperService=self.helper, boneService=self.bone, constraintService=self.constraint, bipService=self.bip)
+        self.volumePreserveBone = VolumePreserveBone(nameService=self.name, animService=self.anim, constService=self.constraint, boneService=self.bone, helperService=self.helper)
+        
+        self.morph = Morph()
+        
+        self.tools = []
 
 # 모듈 레벨에서 전역 인스턴스 생성
 jal = Header.get_instance()

pyjallib/max/helper.py

@@ -264,6 +264,7 @@ class Helper:
         부모 헬퍼 생성
         """
         # 선택된 객체가 있는 경우에만 처리
+        returnHelpers = []
         if rt.selection.count > 0:
             selArray = rt.getCurrentSelection()
             
@@ -297,6 +298,11 @@ class Helper:
                 # 부모 헬퍼로 이름 변경
                 finalName = self.name.replace_name_part("Type", genPoint.name, self.get_name_by_type("Parent"))
                 rt.setProperty(genPoint, "name", finalName)
+                
+                returnHelpers.append(genPoint)
+            
+        return returnHelpers
+        
     
     def create_exp_tm(self):
         """

pyjallib/max/morph.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+모프(Morph) 모듈 - 3ds Max용 모프 타겟 관련 기능 제공
+원본 MAXScript의 morph.ms를 Python으로 변환하였으며, pymxs 모듈 기반으로 구현됨
+"""
+
+from dataclasses import dataclass
+from pymxs import runtime as rt
+
+
+@dataclass
+class MorphChannel:
+    """
+    모프 채널 정보를 저장하는 데이터 클래스
+    """
+    index: int = 0
+    name: str = ""
+    hasData: bool = False
+
+
+class Morph:
+    """
+    모프(Morph) 관련 기능을 제공하는 클래스.
+    MAXScript의 _Morph 구조체 개념을 Python으로 재구현한 클래스이며,
+    3ds Max의 기능들을 pymxs API를 통해 제어합니다.
+    """
+    
+    def __init__(self):
+        """클래스 초기화"""
+        self.channelMaxViewNum = 100
+    
+    def get_modifier_index(self, inObj):
+        """
+        객체에서 Morpher 모디파이어의 인덱스를 찾음
+        
+        Args:
+            inObj: 검색할 객체
+            
+        Returns:
+            Morpher 모디파이어의 인덱스 (없으면 0)
+        """
+        returnVal = 0
+        if len(inObj.modifiers) > 0:
+            for i in range(len(inObj.modifiers)):
+                if rt.classOf(inObj.modifiers[i]) == rt.Morpher:
+                    returnVal = i + 1  # MaxScript는 1부터 시작하므로 +1 추가
+        
+        return returnVal
+    
+    def get_modifier(self, inObj):
+        """
+        객체에서 Morpher 모디파이어를 찾음
+        
+        Args:
+            inObj: 검색할 객체
+            
+        Returns:
+            Morpher 모디파이어 (없으면 None)
+        """
+        returnVal = None
+        modIndex = self.get_modifier_index(inObj)
+        if modIndex > 0:
+            returnVal = inObj.modifiers[modIndex - 1]  # Python 인덱스는 0부터 시작하므로 -1 조정
+        
+        return returnVal
+    
+    def get_channel_num(self, inObj):
+        """
+        객체의 Morpher에 있는 채널 수를 반환
+        
+        Args:
+            inObj: 검색할 객체
+            
+        Returns:
+            모프 채널 수
+        """
+        returnVal = 0
+        morphMod = self.get_modifier(inObj)
+        if morphMod is not None:
+            morphChannelExistance = True
+            morphChannelCounter = 0
+            
+            while morphChannelExistance:
+                for i in range(morphChannelCounter + 1, morphChannelCounter + self.channelMaxViewNum + 1):
+                    if not rt.WM3_MC_HasData(morphMod, i):
+                        returnVal = i - 1
+                        morphChannelExistance = False
+                        break
+                
+                morphChannelCounter += self.channelMaxViewNum
+        
+        return returnVal
+    
+    def get_all_channel_info(self, inObj):
+        """
+        객체의 모든 모프 채널 정보를 가져옴
+        
+        Args:
+            inObj: 검색할 객체
+            
+        Returns:
+            MorphChannel 객체의 리스트
+        """
+        returnVal = []
+        morphMod = self.get_modifier(inObj)
+        
+        if morphMod is not None:
+            channelNum = self.get_channel_num(inObj)
+            if channelNum > 0:
+                for i in range(1, channelNum + 1):
+                    tempChannel = MorphChannel()
+                    tempChannel.index = i
+                    tempChannel.hasData = rt.WM3_MC_HasData(morphMod, i)
+                    tempChannel.name = rt.WM3_MC_GetName(morphMod, i)
+                    returnVal.append(tempChannel)
+        
+        return returnVal
+    
+    def add_target(self, inObj, inTarget, inIndex):
+        """
+        특정 인덱스에 모프 타겟 추가
+        
+        Args:
+            inObj: 모프를 적용할 객체
+            inTarget: 타겟 객체
+            inIndex: 채널 인덱스
+            
+        Returns:
+            성공 여부 (True/False)
+        """
+        returnVal = False
+        morphMod = self.get_modifier(inObj)
+        
+        if morphMod is not None:
+            rt.WM3_MC_BuildFromNode(morphMod, inIndex, inTarget)
+            returnVal = rt.WM3_MC_HasData(morphMod, inIndex)
+        
+        return returnVal
+    
+    def add_targets(self, inObj, inTargetArray):
+        """
+        여러 타겟 객체를 순서대로 모프 채널에 추가
+        
+        Args:
+            inObj: 모프를 적용할 객체
+            inTargetArray: 타겟 객체 배열
+        """
+        morphMod = self.get_modifier(inObj)
+        
+        if morphMod is not None:
+            for i in range(len(inTargetArray)):
+                rt.WM3_MC_BuildFromNode(morphMod, i + 1, inTargetArray[i])
+    
+    def get_all_channel_name(self, inObj):
+        """
+        객체의 모든 모프 채널 이름을 가져옴
+        
+        Args:
+            inObj: 검색할 객체
+            
+        Returns:
+            채널 이름 리스트
+        """
+        returnVal = []
+        channelArray = self.get_all_channel_info(inObj)
+        
+        if len(channelArray) > 0:
+            returnVal = [item.name for item in channelArray]
+        
+        return returnVal
+    
+    def get_channel_name(self, inObj, inIndex):
+        """
+        특정 인덱스의 모프 채널 이름을 가져옴
+        
+        Args:
+            inObj: 검색할 객체
+            inIndex: 채널 인덱스
+            
+        Returns:
+            채널 이름 (없으면 빈 문자열)
+        """
+        returnVal = ""
+        channelArray = self.get_all_channel_info(inObj)
+        
+        try:
+            if len(channelArray) > 0:
+                returnVal = channelArray[inIndex - 1].name
+        except:
+            returnVal = ""
+        
+        return returnVal
+    
+    def get_channelIndex(self, inObj, inName):
+        """
+        채널 이름으로 모프 채널 인덱스를 가져옴
+        
+        Args:
+            inObj: 검색할 객체
+            inName: 채널 이름
+            
+        Returns:
+            채널 인덱스 (없으면 0)
+        """
+        returnVal = 0
+        channelArray = self.get_all_channel_info(inObj)
+        
+        if len(channelArray) > 0:
+            for item in channelArray:
+                if item.name == inName:
+                    returnVal = item.index
+                    break
+        
+        return returnVal
+    
+    def get_channel_value_by_name(self, inObj, inName):
+        """
+        채널 이름으로 모프 채널 값을 가져옴
+        
+        Args:
+            inObj: 검색할 객체
+            inName: 채널 이름
+            
+        Returns:
+            채널 값 (0.0 ~ 100.0)
+        """
+        returnVal = 0.0
+        channelIndex = self.get_channelIndex(inObj, inName)
+        morphMod = self.get_modifier(inObj)
+        
+        if channelIndex > 0:
+            try:
+                returnVal = rt.WM3_MC_GetValue(morphMod, channelIndex)
+            except:
+                returnVal = 0.0
+        
+        return returnVal
+    
+    def get_channel_value_by_index(self, inObj, inIndex):
+        """
+        인덱스로 모프 채널 값을 가져옴
+        
+        Args:
+            inObj: 검색할 객체
+            inIndex: 채널 인덱스
+            
+        Returns:
+            채널 값 (0.0 ~ 100.0)
+        """
+        returnVal = 0
+        morphMod = self.get_modifier(inObj)
+        
+        if morphMod is not None:
+            try:
+                returnVal = rt.WM3_MC_GetValue(morphMod, inIndex)
+            except:
+                returnVal = 0
+        
+        return returnVal
+    
+    def set_channel_value_by_name(self, inObj, inName, inVal):
+        """
+        채널 이름으로 모프 채널 값을 설정
+        
+        Args:
+            inObj: 모프를 적용할 객체
+            inName: 채널 이름
+            inVal: 설정할 값 (0.0 ~ 100.0)
+            
+        Returns:
+            성공 여부 (True/False)
+        """
+        returnVal = False
+        morphMod = self.get_modifier(inObj)
+        channelIndex = self.get_channelIndex(inObj, inName)
+        
+        if channelIndex > 0:
+            try:
+                rt.WM3_MC_SetValue(morphMod, channelIndex, inVal)
+                returnVal = True
+            except:
+                returnVal = False
+        
+        return returnVal
+    
+    def set_channel_value_by_index(self, inObj, inIndex, inVal):
+        """
+        인덱스로 모프 채널 값을 설정
+        
+        Args:
+            inObj: 모프를 적용할 객체
+            inIndex: 채널 인덱스
+            inVal: 설정할 값 (0.0 ~ 100.0)
+            
+        Returns:
+            성공 여부 (True/False)
+        """
+        returnVal = False
+        morphMod = self.get_modifier(inObj)
+        
+        if morphMod is not None:
+            try:
+                rt.WM3_MC_SetValue(morphMod, inIndex, inVal)
+                returnVal = True
+            except:
+                returnVal = False
+        
+        return returnVal
+    
+    def set_channel_name_by_name(self, inObj, inTargetName, inNewName):
+        """
+        채널 이름을 이름으로 검색하여 변경
+        
+        Args:
+            inObj: 모프를 적용할 객체
+            inTargetName: 대상 채널의 현재 이름
+            inNewName: 설정할 새 이름
+            
+        Returns:
+            성공 여부 (True/False)
+        """
+        returnVal = False
+        channelIndex = self.get_channelIndex(inObj, inTargetName)
+        morphMod = self.get_modifier(inObj)
+        
+        if channelIndex > 0:
+            rt.WM3_MC_SetName(morphMod, channelIndex, inNewName)
+            returnVal = True
+        
+        return returnVal
+    
+    def set_channel_name_by_index(self, inObj, inIndex, inName):
+        """
+        채널 이름을 인덱스로 검색하여 변경
+        
+        Args:
+            inObj: 모프를 적용할 객체
+            inIndex: 대상 채널 인덱스
+            inName: 설정할 이름
+            
+        Returns:
+            성공 여부 (True/False)
+        """
+        returnVal = False
+        morphMod = self.get_modifier(inObj)
+        
+        if morphMod is not None:
+            try:
+                rt.WM3_MC_SetName(morphMod, inIndex, inName)
+                returnVal = True
+            except:
+                returnVal = False
+        
+        return returnVal
+    
+    def reset_all_channel_value(self, inObj):
+        """
+        모든 모프 채널 값을 0으로 리셋
+        
+        Args:
+            inObj: 리셋할 객체
+        """
+        totalChannelNum = self.get_channel_num(inObj)
+        
+        if totalChannelNum > 0:
+            for i in range(1, totalChannelNum + 1):
+                self.set_channel_value_by_index(inObj, i, 0.0)
+    
+    def extract_morph_channel_geometry(self, obj, _feedback_=False):
+        """
+        모프 채널의 기하학적 형태를 추출하여 개별 객체로 생성
+        
+        Args:
+            obj: 추출 대상 객체
+            _feedback_: 피드백 메시지 출력 여부
+            
+        Returns:
+            추출된 객체 배열
+        """
+        extractedObjs = []
+        morphMod = self.get_modifier(obj)
+        
+        if rt.IsValidMorpherMod(morphMod):
+            # 데이터가 있는 모든 채널 인덱스 수집
+            channels = [i for i in range(1, rt.WM3_NumberOfChannels(morphMod) + 1) 
+                        if rt.WM3_MC_HasData(morphMod, i)]
+            
+            for i in channels:
+                channelName = rt.WM3_MC_GetName(morphMod, i)
+                rt.WM3_MC_SetValue(morphMod, i, 100.0)
+                
+                objSnapshot = rt.snapshot(obj)
+                objSnapshot.name = channelName
+                extractedObjs.append(objSnapshot)
+                
+                rt.WM3_MC_SetValue(morphMod, i, 0.0)
+                
+                if _feedback_:
+                    print(f" - FUNCTION - [ extract_morph_channel_geometry ] - Extracted ---- {objSnapshot.name} ---- successfully!!")
+        else:
+            if _feedback_:
+                print(f" - FUNCTION - [ extract_morph_channel_geometry ] - No valid morpher found on ---- {obj.name} ---- ")
+        
+        return extractedObjs

pyjallib/max/name.py

@@ -6,6 +6,8 @@
 3ds Max에 특화된 네이밍 기능 (pymxs 의존)
 """
 
+import os
+
 from pymxs import runtime as rt
 from pyjallib.naming import Naming
 from pyjallib.namePart import NamePart, NamePartType
@@ -35,35 +37,9 @@ class Name(Naming):
             # 사용자가 지정한 설정 파일 사용
             self.load_from_config_file(configPath=configPath)
         else:
-            # 설정 파일이 없는 경우, 기본 설정값으로 초기화
-            # Base 부분 (PREFIX 타입)
-            basePart = NamePart("Base", NamePartType.PREFIX, 
-                             ["b", "Bip001"], 
-                             ["SkinBone", "Biped"])
-            # Type 부분 (PREFIX 타입)
-            typePart = NamePart("Type", NamePartType.PREFIX, 
-                             ["P", "Dum", "Exp", "IK", "T"], 
-                             ["Parent", "Dummy", "ExposeTM", "IK", "Target"])
-            # Side 부분 (PREFIX 타입)
-            sidePart = NamePart("Side", NamePartType.PREFIX,
-                             ["L", "R"], 
-                             ["Left", "Right"],
-                             True)
-            # FrontBack 부분 (PREFIX 타입)
-            frontBackPart = NamePart("FrontBack", NamePartType.PREFIX,
-                                 ["F", "B"], 
-                                 ["Front", "Back"],
-                                 True)
-            # RealName 부분 (REALNAME 타입)
-            realNamePart = NamePart("RealName", NamePartType.REALNAME, [], [])
-            # Index 부분 (INDEX 타입)
-            indexPart = NamePart("Index", NamePartType.INDEX, [], [])
-            # Nub 부분 (SUFFIX 타입)
-            nubPart = NamePart("Nub", NamePartType.SUFFIX,
-                             ["Nub"], 
-                             ["Nub"])
-            # 기본 순서대로 설정
-            self._nameParts = [basePart, typePart, sidePart, frontBackPart, realNamePart, indexPart, nubPart]
+            configDir = os.path.join(os.path.dirname(__file__), "ConfigFiles")
+            nameConfigDir = os.path.join(configDir, "3DSMaxNamingConfig.json")
+            self.load_from_config_file(configPath=nameConfigDir)
     
     # NamePart 직접 액세스 메소드들
     # get_<NamePart 이름>_values 메소드들

pyjallib/max/ui/Container.py

@@ -0,0 +1,153 @@
+"""
+PySide2 Collapsible Widget/ frameLayout
+
+Origianlly created by: aronamao
+on GitHub: https://github.com/aronamao/PySide2-Collapsible-Widget
+"""
+
+
+from PySide2 import QtWidgets, QtGui, QtCore
+
+
+class Header(QtWidgets.QWidget):
+    """Header class for collapsible group"""
+
+    def __init__(self, name, content_widget):
+        """Header Class Constructor to initialize the object.
+
+        Args:
+            name (str): Name for the header
+            content_widget (QtWidgets.QWidget): Widget containing child elements
+        """
+        super(Header, self).__init__()
+        self.content = content_widget
+
+        # Try to load icons from resources, use fallback if not available
+        self.expand_ico = QtGui.QPixmap(":teDownArrow.png")
+        self.collapse_ico = QtGui.QPixmap(":teRightArrow.png")
+
+        # Check if icons were loaded properly (not empty)
+        if self.expand_ico.isNull() or self.collapse_ico.isNull():
+            # Create fallback icons programmatically
+            self.expand_ico = self._create_arrow_icon("down")
+            self.collapse_ico = self._create_arrow_icon("right")
+
+        self.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
+
+        stacked = QtWidgets.QStackedLayout(self)
+        stacked.setStackingMode(QtWidgets.QStackedLayout.StackAll)
+        background = QtWidgets.QLabel()
+        background.setStyleSheet("QLabel{ background-color: rgb(81, 81, 81); border-radius:2px}")
+
+        widget = QtWidgets.QWidget()
+        layout = QtWidgets.QHBoxLayout(widget)
+
+        self.icon = QtWidgets.QLabel()
+        self.icon.setPixmap(self.expand_ico)
+        layout.addWidget(self.icon)
+        layout.setContentsMargins(11, 0, 11, 0)
+
+        font = QtGui.QFont()
+        font.setBold(True)
+        label = QtWidgets.QLabel(name)
+        label.setFont(font)
+
+        layout.addWidget(label)
+        layout.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding))
+
+        stacked.addWidget(widget)
+        stacked.addWidget(background)
+        background.setMinimumHeight(layout.sizeHint().height() * 1.5)
+
+    def mousePressEvent(self, *args):
+        """Handle mouse events, call the function to toggle groups"""
+        self.expand() if not self.content.isVisible() else self.collapse()
+
+    def expand(self):
+        self.content.setVisible(True)
+        self.icon.setPixmap(self.expand_ico)
+
+    def collapse(self):
+        self.content.setVisible(False)
+        self.icon.setPixmap(self.collapse_ico)
+
+    def _create_arrow_icon(self, direction):
+        """Create a fallback arrow icon when resource icons are not available.
+
+        Args:
+            direction (str): Direction of the arrow ('down' or 'right')
+
+        Returns:
+            QtGui.QPixmap: Created arrow icon
+        """
+        # Create a pixmap for the arrow
+        pixmap = QtGui.QPixmap(16, 16)
+        pixmap.fill(QtGui.QColor(0, 0, 0, 0))  # Transparent background
+
+        # Create a painter to draw the arrow
+        painter = QtGui.QPainter(pixmap)
+        painter.setRenderHint(QtGui.QPainter.Antialiasing)
+
+        # Set the pen and brush
+        pen = QtGui.QPen(QtGui.QColor(200, 200, 200))
+        painter.setPen(pen)
+        painter.setBrush(QtGui.QBrush(QtGui.QColor(200, 200, 200)))
+
+        # Draw the arrow based on direction
+        if direction == "down":
+            points = [QtCore.QPoint(4, 6), QtCore.QPoint(12, 6), QtCore.QPoint(8, 10)]
+        else:  # right arrow
+            points = [QtCore.QPoint(6, 4), QtCore.QPoint(6, 12), QtCore.QPoint(10, 8)]
+
+        painter.drawPolygon(points)
+        painter.end()
+
+        return pixmap
+
+
+class Container(QtWidgets.QWidget):
+    """Class for creating a collapsible group similar to how it is implement in Maya
+
+        Examples:
+            Simple example of how to add a Container to a QVBoxLayout and attach a QGridLayout
+
+            >>> layout = QtWidgets.QVBoxLayout()
+            >>> container = Container("Group")
+            >>> layout.addWidget(container)
+            >>> content_layout = QtWidgets.QGridLayout(container.contentWidget)
+            >>> content_layout.addWidget(QtWidgets.QPushButton("Button"))
+    """
+    def __init__(self, name, color_background=True):
+        """Container Class Constructor to initialize the object
+
+        Args:
+            name (str): Name for the header
+            color_background (bool): whether or not to color the background lighter like in maya
+        """
+        super(Container, self).__init__()
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(0, 2, 0, 0)
+        layout.setSpacing(0)
+        self._content_widget = QtWidgets.QWidget()
+        if color_background:
+            self._content_widget.setStyleSheet('''
+                .QWidget{
+                    background-color: rgb(81, 81, 81); 
+                }
+            ''')
+        header = Header(name, self._content_widget)
+        layout.addWidget(header)
+        layout.addWidget(self._content_widget)
+
+        # assign header methods to instance attributes so they can be called outside of this class
+        self.collapse = header.collapse
+        self.expand = header.expand
+        self.toggle = header.mousePressEvent
+
+    @property
+    def contentWidget(self):
+        """Getter for the content widget
+
+        Returns: Content widget
+        """
+        return self._content_widget

pyjallib/max/volumePreserveBone.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+관절 부피 유지 본(Volume preserve Bone) 모듈 - 3ds Max용 관절의 부피를 유지하기 위해 추가되는 중간본들을 위한 모듈
+"""
+
+from pymxs import runtime as rt
+
+# Import necessary service classes for default initialization
+from .name import Name
+from .anim import Anim
+from .constraint import Constraint
+from .bone import Bone
+from .helper import Helper
+
+class VolumePreserveBone:
+    """
+    관절 부피 유지 본(Volume preserve Bone) 클래스
+    3ds Max에서 관절의 부피를 유지하기 위해 추가되는 중간본들을 위한 클래스
+    """
+    def __init__(self, nameService=None, animService=None, constService=None, boneService=None, helperService=None):
+        self.name = nameService if nameService else Name()
+        self.anim = animService if animService else Anim()
+        # Ensure dependent services use the potentially newly created instances
+        self.const = constService if constService 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)
+        
+    def create_rot_helpers(self, inObj, inRotScale=0.5):
+        if rt.isValidNode(inObj) == False or rt.isValidNode(inObj.parent) == False:
+            return False
+        
+        volName = self.name.get_RealName(inObj.name)
+        volName = volName + "Vol"
+        
+        parentObj = inObj.parent
+        
+        rt.select(inObj)
+        rotHelpers = self.helper.create_helper(make_two=True)
+        rotHelpers[0].parent = inObj
+        rotHelpers[1].parent = parentObj
+        
+        rotHelpers[0].name = self.name.replace_RealName(rotHelpers[0].name, volName)
+        rotHelpers[1].name = self.name.replace_RealName(rotHelpers[1].name, volName + self.name.get_name_part_value_by_description("Type", "Target"))
+        
+        rotConst = self.const.assign_rot_const_multi(rotHelpers[0], [inObj, rotHelpers[1]])
+        rotConst.setWeight(1, inRotScale * 100.0)
+        rotConst.setWeight(2, (1.0 - inRotScale) * 100.0)
+        
+        return rotHelpers
+        
+    def create_init_bone(self, inObj, inVolumeSize, inRotHelpers, inRotAxis="Z", inTransAxis="PosY", inTransScale=1.0):
+        if rt.isValidNode(inObj) == False or rt.isValidNode(inObj.parent) == False:
+            return False
+        
+        returnVal = {
+            "Bones": [],
+            "Helpers": []
+        }
+        
+        volName = self.name.get_RealName(inObj.name)
+        volName = volName + "Vol"
+        
+        # ExposeTM을 사용하여 회전값을 가져오는 방법
+        # rt.select(inObj)
+        # expHelper = self.helper.create_exp_tm()[0]
+        # expHelper.parent = parentObj
+        # expHelper.exposeNode = rotHelpers[0]
+        # expHelper.useParent = False
+        # expHelper.localReferenceNode = rotHelpers[1]
+        # expHelper.eulerXOrder = 5
+        # expHelper.eulerYOrder = 5
+        # expHelper.eulerZOrder = 5
+    
+        # expHelper.name = self.name.replace_RealName(expHelper.name, volName)
+        
+        boneGenHelperA = rt.point()
+        boneGenHelperB = rt.point()
+        boneGenHelperA.transform = inObj.transform
+        boneGenHelperB.transform = inObj.transform
+        
+        if inTransAxis == "PosX":
+            self.anim.move_local(boneGenHelperB, inVolumeSize, 0, 0)
+        elif inTransAxis == "NegX":
+            self.anim.move_local(boneGenHelperB, -inVolumeSize, 0, 0)
+        elif inTransAxis == "PosY":
+            self.anim.move_local(boneGenHelperB, 0, inVolumeSize, 0)
+        elif inTransAxis == "NegY":
+            self.anim.move_local(boneGenHelperB, 0, -inVolumeSize, 0)
+        elif inTransAxis == "PosZ":
+            self.anim.move_local(boneGenHelperB, 0, 0, inVolumeSize)
+        elif inTransAxis == "NegZ":
+            self.anim.move_local(boneGenHelperB, 0, 0, -inVolumeSize)
+            
+        row = ""
+        sourceUpAxist = 0
+        upAxis = 0
+        if inRotAxis == "X":
+            row = "row1"
+            sourceUpAxist = 1
+            upAxis = 1
+        elif inRotAxis == "Y":
+            row = "row3"
+            sourceUpAxist = 2
+            upAxis = 2
+        elif inRotAxis == "Z":
+            row = "row2"
+            sourceUpAxist = 3
+            upAxis = 3
+            
+        volumeBoneName = self.name.replace_RealName(self.name.get_string(inObj.name), volName + inRotAxis + inTransAxis)
+        
+        volumeBones = self.bone.create_simple_bone(inVolumeSize, volumeBoneName)
+        volumeBones[0].transform = inObj.transform
+        lookatConst = self.const.assign_lookat(volumeBones[0], boneGenHelperB)
+        lookatConst.pickUpNode = inObj
+        lookatConst.upnode_world = False
+        lookatConst.StoUP_axis = sourceUpAxist
+        lookatConst.upnode_axis = upAxis
+        self.const.collapse(volumeBones[0])
+        
+        rt.delete(boneGenHelperA)
+        rt.delete(boneGenHelperB)
+        
+        volumeBones[0].parent = inRotHelpers[0]
+        rt.select(volumeBones[0])
+        parentHelper = self.helper.create_parent_helper()[0]
+        
+        posConst = self.const.assign_pos_script_controller(volumeBones[0])
+        # posConst.AddNode("rotExp", expHelper)
+        posConst.AddNode("rotObj", inRotHelpers[0])
+        posConst.AddNode("rotParent", inRotHelpers[1])
+        
+        posConstCode = f""
+        posConstCode += f"local parentXAxis = (normalize rotParent.objectTransform.{row})\n"
+        posConstCode += f"local rotObjXAxis = (normalize rotObj.objectTransform.{row})\n"
+        posConstCode += f"local rotAmount = (1.0 - (dot parentXAxis rotObjXAxis))/2.0\n"
+        posConstCode += f"local posX = rotAmount * {inVolumeSize*inTransScale}\n"
+        posConstCode += f"[posX, 0.0, 0.0]\n"
+        
+        posConst.SetExpression(posConstCode)
+        
+        returnVal["Bones"] = volumeBones
+        returnVal["Helpers"] = [parentHelper]
+        
+        return returnVal
+    
+    def create_bones(self,inObj, inVolumeSize, inRotAxises, inRotScale, inTransAxiese, inTransScales):
+        if rt.isValidNode(inObj) == False or rt.isValidNode(inObj.parent) == False:
+            return False
+        
+        if not len(inTransAxiese) == len(inTransScales) == len(inTransAxiese) == len(inRotAxises):
+            return False
+        
+        rotHelpers = self.create_rot_helpers(inObj, inRotScale=inRotScale)
+        
+        returnVal = {
+            "Bones": [],
+            "Helpers": []
+        }
+        
+        for i in range(len(inRotAxises)):
+            genResult = self.create_init_bone(inObj, inVolumeSize, rotHelpers, inRotAxises[i], inTransAxiese[i], inTransScales[i])
+            returnVal["Bones"].extend(genResult["Bones"])
+            returnVal["Helpers"].extend(genResult["Helpers"])
+        
+        returnVal["Helpers"].insert(0, rotHelpers[0])
+        returnVal["Helpers"].insert(1, rotHelpers[1])
+            
+        return returnVal

{pyjallib-0.1.6.dist-info → pyjallib-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjallib
-Version: 0.1.6
+Version: 0.1.8
 Summary: A utility library for 3D game character development pipelines.
 Author-email: Dongseok Kim <jalnagakds@gmail.com>
 Requires-Python: >=3.10

{pyjallib-0.1.6.dist-info → pyjallib-0.1.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyjallib/__init__.py,sha256=Vn47aG6w0P4VzzOm7lnSp7G38YVsI40nTwg5CClgdR4,460
+pyjallib/__init__.py,sha256=FD41BluMZ_gDt-gXhEAzIwNyWn_tokcUoZMKTpn_fN8,460
 pyjallib/namePart.py,sha256=D1hnFNnZbrNicAiW2ZUaIT0LU5pro3uFYrFYOEjt7_Y,24001
 pyjallib/nameToPath.py,sha256=61EWrc0Wc1K1Qsc4G6jewIccI0IHbiZWroRcU_lX1Wc,4664
 pyjallib/naming.py,sha256=jJ6w0n_nnUE2uZy_I4KFsMx95Ij3_KvSjhVvQQplxpw,36621
@@ -7,30 +7,33 @@ pyjallib/perforce.py,sha256=YnKAKlbBss4cl66R4nQbr-bsYjTneLzGYaZ187kOSpA,29872
 pyjallib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyjallib/reloadModules.py,sha256=RAEG3IxzJ0TlsjvnZwJt56JOkc2j8voqAnRbfQuZ44g,1151
 pyjallib/ConfigFiles/namingConfig.json,sha256=Ov4bbVJb6qodPaooU63e11YUMGXXPWFAA4AQq1sLBYU,1486
-pyjallib/max/__init__.py,sha256=JofFmmSDMs8hWSAnS3yKw9y_o0IniQiKfzLtVUI9v8w,888
+pyjallib/max/__init__.py,sha256=1058Mvp_Ebf3DG_DVkAC4o_frQPq7F6-m-C-Ccme64k,1064
 pyjallib/max/align.py,sha256=HKjCViQCuicGmtvHB6xxVv4BEGEBGtV2gO3NvR_6R2A,5183
 pyjallib/max/anim.py,sha256=-shQeE0WeAeCefc8FoI63dNDLHhz0uzOJ4shp5AL_Cs,25135
-pyjallib/max/autoClavicle.py,sha256=rJtXVcTEksstaXF4s1i-0FwhVkPWJFRxlVq8Gyw45Rg,5792
+pyjallib/max/autoClavicle.py,sha256=FQGFkucRu670TpkEUs8lQRJyNUykvtxF9rZiPjHoH3s,7517
 pyjallib/max/bip.py,sha256=m6eA-rg-MghYSxbzj-YXa0KJFPm1wiOsOqyJu76_hlY,16967
 pyjallib/max/bone.py,sha256=GYs3Uohc0AMkLWZAqZTc1DET-WDgZlvlkhSUaBeszvk,33161
-pyjallib/max/constraint.py,sha256=WXB6fJ0er4EIZBZ7voQK_bFeqtgjopCKCpwiBn3QyiI,40055
+pyjallib/max/constraint.py,sha256=gVdGezkRmzWRtUZeAdLnWfmvhgy8HAhD_dXmyI4xvUw,41282
 pyjallib/max/groinBone.py,sha256=rEZQ7tAXgcZ3NedFacIyvfG07nI8rgF_pVufy-hnKuo,3830
-pyjallib/max/header.py,sha256=06rzzaOGDtxQGD4SwAFX8nlxNn8lP_gQ_qY0FGZYBFk,2736
-pyjallib/max/helper.py,sha256=s_rEhY1wNUrwyEN6osuUuOsnqFAQo8_X0Dcf3R89NY0,18526
+pyjallib/max/header.py,sha256=s2no3jRenY4b-xjofKwV9TGbO9doE4KH8paeBQA7qko,3071
+pyjallib/max/helper.py,sha256=WPoxSoHAFXmAPx_CRJFWBNXn4S2k04UK-1J9x6nIv84,18674
 pyjallib/max/layer.py,sha256=e9Mn8h7xf0oBYST3QIpyBpLMl8qpWTExO9Y6yH6rKc0,8795
 pyjallib/max/link.py,sha256=J3z9nkP8ZxAh9yYhR16tjQFCJTCYZMSB0MGbSHfA7uI,2592
 pyjallib/max/mirror.py,sha256=j8LnsXowyTINzvtWsvCNaDsQ6v7u2RjlY50R8v5JCuc,14517
-pyjallib/max/name.py,sha256=z_fclfutesFxhk2hVliqZGnRQauKcB8LJpRbKQ5cYAc,16703
+pyjallib/max/morph.py,sha256=I8HRYx4NznL6GZL4CbT9iTv05SeaBW_mJJ4PzMxCBkw,12664
+pyjallib/max/name.py,sha256=DcJt2td-N7vfUGyWazdGTD4-0JW-noa7z5nwc6SHm6I,15337
 pyjallib/max/select.py,sha256=HMJD2WNX3zVBEeYrj0UX2YXM3fHNItfw6UtQSItNsoU,9487
 pyjallib/max/skin.py,sha256=5mBzG2wSUxoGlkFeb9Ys8uUxOwuZRGeqUMTI9LiWWZU,41937
 pyjallib/max/twistBone.py,sha256=0Z-Z-OiTPM0fXAnzgol0tiY7Kms6-qrEuVCHsCVVbUc,20338
-pyjallib/max/ConfigFiles/3DSMaxNamingConfig.json,sha256=_gIsm80fGazA6jUsoBAVxukGNydj6MDgBgGmzb0WQa4,3717
+pyjallib/max/volumePreserveBone.py,sha256=mTtbAOKRjkbVO-PQQMt6FZzAawtUMbwGgj8XO1n9SV8,7193
+pyjallib/max/ConfigFiles/3DSMaxNamingConfig.json,sha256=PBUYawCELG0aLNRdTh6j-Yka4eNdmpF4P8iRyp0Ngpg,3717
 pyjallib/max/macro/jal_macro_align.py,sha256=t0gQjybkHYAvPtjT5uWjUQd1vsXIsxOkdYfhFWduxJU,4270
 pyjallib/max/macro/jal_macro_bone.py,sha256=QS492tskLrARGIFDmbKEwJw7122xJga0ZP5z8WVVRn8,12422
 pyjallib/max/macro/jal_macro_constraint.py,sha256=0gpfan7hXES9jhnpZVlxWtCbqUCyGxjtSmVMbp7nUh8,4160
 pyjallib/max/macro/jal_macro_helper.py,sha256=ODwAl4C6WK2UE45dqpfw90TgN5vDjLJvODvYeO8tj4o,12906
 pyjallib/max/macro/jal_macro_link.py,sha256=xkgcCX0fJw4vLfMYybtfUklT3dgcO0tHfpt2X9BfWLw,1193
 pyjallib/max/macro/jal_macro_select.py,sha256=-r24l84XmDEM4W6H0r1jOBErp3q0UxNrr0m9oAHSgkE,2289
-pyjallib-0.1.6.dist-info/METADATA,sha256=CcIpikrV2_YUnr8eiNH2Aggz2DKCsqWx_d81e5N9ORM,869
-pyjallib-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyjallib-0.1.6.dist-info/RECORD,,
+pyjallib/max/ui/Container.py,sha256=QSk3oCqhfiR4aglSSkherRGAyPFqMRUt83L-0ENBz-s,5571
+pyjallib-0.1.8.dist-info/METADATA,sha256=7dGxma4w0wrSzOlLcLnI1dN0ha3emWufRpVDWxkCaXY,869
+pyjallib-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyjallib-0.1.8.dist-info/RECORD,,