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

pyjallib/max/fbxHandler.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+FBXHandler 모듈
+3ds Max에서 FBX 파일을 익스포트/임포트하는 기능을 제공
+이 모듈은 pymxs를 사용하여 3ds Max와 통신하며, FBX 익스포트 및 임포트 옵션을 설정하고 파일을 처리합니다.
+"""
+
+from pymxs import runtime as rt
+import os
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+class FBXHandler:
+    """
+    3ds Max FBX 파일 익스포트/임포트를 위한 클래스
+    pymxs를 사용하여 3ds Max와 통신
+    """
+    
+    def __init__(self):
+        """FBX 핸들러 초기화"""
+        self._setup_fbx_plugin()
+    
+    def _setup_fbx_plugin(self):
+        """FBX 플러그인 로드 및 초기화"""
+        rt.pluginManager.loadClass(rt.FbxExporter)
+        rt.pluginManager.loadClass(rt.FbxImporter)
+    
+    def _get_export_fbx_class_index(self) -> int:
+        """FBX 익스포터 클래스 인덱스 가져오기"""
+        exporterPlugin = rt.exporterPlugin
+        for i, cls in enumerate(exporterPlugin.classes):
+            if "FBX" in str(cls):
+                return i + 1  # 1-based index
+        return 0
+    
+    def _get_import_fbx_class_index(self) -> int:
+        """FBX 임포터 클래스 인덱스 가져오기"""
+        importerPlugin = rt.importerPlugin
+        for i, cls in enumerate(importerPlugin.classes):
+            if "FBX" in str(cls):
+                return i + 1  # 1-based index
+        return 0
+    
+    def _set_export_options(self):
+        """FBX 익스포트 옵션 설정"""
+        # FBX 익스포트 프리셋 리셋
+        rt.FBXExporterSetParam("ResetExport")
+        
+        # 지오메트리 옵션
+        rt.FBXExporterSetParam("SmoothingGroups", True)
+        rt.FBXExporterSetParam("NormalsPerPoly", False)
+        rt.FBXExporterSetParam("TangentSpaceExport", True)
+        rt.FBXExporterSetParam("SmoothMeshExport", False)
+        rt.FBXExporterSetParam("Preserveinstances", False)
+        rt.FBXExporterSetParam("SelectionSetExport", False)
+        rt.FBXExporterSetParam("GeomAsBone", False)
+        rt.FBXExporterSetParam("Triangulate", False)
+        rt.FBXExporterSetParam("PreserveEdgeOrientation", True)
+        
+        # 애니메이션 옵션
+        rt.FBXExporterSetParam("Animation", True)
+        rt.FBXExporterSetParam("UseSceneName", True)
+        rt.FBXExporterSetParam("Removesinglekeys", False)
+        rt.FBXExporterSetParam("BakeAnimation", True)
+        rt.FBXExporterSetParam("Skin", True)
+        rt.FBXExporterSetParam("Shape", True)
+        
+        # 포인트 캐시
+        rt.FBXExporterSetParam("PointCache", False)
+        
+        # 카메라 및 라이트
+        rt.FBXExporterSetParam("Cameras", False)
+        rt.FBXExporterSetParam("Lights", False)
+        
+        # 텍스처
+        rt.FBXExporterSetParam("EmbedTextures", False)
+        
+        # 기타 옵션
+        rt.FBXExporterSetParam("UpAxis", "Z")
+        rt.FBXExporterSetParam("GenerateLog", False)
+        rt.FBXExporterSetParam("ShowWarnings", False)
+        rt.FBXExporterSetParam("ASCII", False)
+        rt.FBXExporterSetParam("FileVersion", "FBX202031")
+    
+    def _set_import_options(self, inImportMode: str = "add_and_update_animation", inUpAxis: str = "Z"):
+        """FBX 임포트 옵션 설정
+        
+        Args:
+            inImportMode: 임포트 모드 ('add_and_update_animation' 또는 'update_animation')
+        """
+        # FBX 임포트 프리셋 리셋
+        rt.FBXImporterSetParam("ResetImport")
+        
+        # 임포트 모드 설정
+        if inImportMode == "update_animation":
+            rt.FBXImporterSetParam("Mode", rt.Name("exmerge"))  # Update Animation 모드
+        else:  # "add_and_update_animation" (기본값)
+            rt.FBXImporterSetParam("Mode", rt.Name("merge"))  # Add and Update Animation 모드
+        
+        rt.FBXImporterSetParam("SmoothingGroups", True)
+        rt.FBXImporterSetParam("Animation", True)
+        rt.FBXImporterSetParam("BakeAnimationLayers", True)
+        rt.FBXImporterSetParam("FillTimeline", True)
+        rt.FBXImporterSetParam("Skin", True)
+        rt.FBXImporterSetParam("Shape", True)
+        rt.FBXImporterSetParam("Cameras", False)
+        rt.FBXImporterSetParam("Lights", False)
+        rt.FBXImporterSetParam("GenerateLog", False)
+        rt.FBXImporterSetParam("GenerateLog", False)
+        rt.FBXImporterSetParam("ImportBoneAsDummy", True)
+        rt.FBXImporterSetParam("UpAxis", inUpAxis)
+    
+    def set_fbx_exporting_anim_range(self, inStartFrame: Optional[int] = None, inEndFrame: Optional[int] = None):
+        """애니메이션 범위 설정
+        
+        Args:
+            inStartFrame: 시작 프레임 (None이면 현재 애니메이션 범위 사용)
+            inEndFrame: 끝 프레임 (None이면 현재 애니메이션 범위 사용)
+        """
+        if inStartFrame is None or inEndFrame is None:
+            # 매개변수가 없으면 현재 Max 파일의 애니메이션 범위 사용
+            animRange = rt.animationrange
+            startFrame = inStartFrame if inStartFrame is not None else animRange.start
+            endFrame = inEndFrame if inEndFrame is not None else animRange.end
+        else:
+            # 매개변수가 있으면 해당 값 사용
+            startFrame = inStartFrame
+            endFrame = inEndFrame
+        
+        rt.FBXExporterSetParam("BakeFrameStart", startFrame)
+        rt.FBXExporterSetParam("BakeFrameEnd", endFrame)
+    
+    def export_selection(self, inExportFile: str, inMatchAnimRange: bool = True, inStartFrame: Optional[int] = None, inEndFrame: Optional[int] = None) -> bool:
+        """
+        선택된 오브젝트를 FBX로 익스포트
+        
+        Args:
+            inExportFile: 익스포트할 파일 경로
+            inMatchAnimRange: 현재 애니메이션 범위에 맞출지 여부
+            inStartFrame: 시작 프레임 (None이면 현재 애니메이션 범위 사용)
+            inEndFrame: 끝 프레임 (None이면 현재 애니메이션 범위 사용)
+            
+        Returns:
+            bool: 익스포트 성공 여부
+        """
+        # 파일 경로 검증 및 디렉토리 생성
+        filePath = Path(inExportFile)
+        filePath.parent.mkdir(parents=True, exist_ok=True)
+        
+        # 선택된 오브젝트가 있는지 확인
+        if len(rt.selection) == 0:
+            return False
+        
+        # FBX 익스포터 클래스 인덱스 가져오기
+        exportClassIndex = self._get_export_fbx_class_index()
+        if exportClassIndex == 0:
+            return False
+        
+        # FBX 익스포트 옵션 설정
+        self._set_export_options()
+        
+        # 애니메이션 범위 설정
+        if inMatchAnimRange:
+            self.set_fbx_exporting_anim_range(inStartFrame, inEndFrame)
+        
+        # 익스포트 실행
+        exporterPlugin = rt.exporterPlugin
+        result = rt.exportFile(
+            str(filePath),
+            rt.Name("noPrompt"),
+            using=exporterPlugin.classes[exportClassIndex - 1],  # 0-based index로 변환
+            selectedOnly=True
+        )
+        
+        return result
+    
+    def import_fbx(self, inImportFile: str, inImportMode: str = "add_and_update_animation", inUpAxis: str = "Z") -> bool:
+        """
+        FBX 파일을 임포트
+        
+        Args:
+            inImportFile: 임포트할 파일 경로
+            inImportMode: 임포트 모드 ('add_and_update_animation' 또는 'update_animation')
+                
+        Returns:
+            bool: 임포트 성공 여부
+        """
+        # 파일 존재 여부 확인
+        filePath = Path(inImportFile)
+        if not filePath.exists():
+            return False
+        
+        # FBX 임포터 클래스 인덱스 가져오기
+        importClassIndex = self._get_import_fbx_class_index()
+        if importClassIndex == 0:
+            return False
+        
+        # FBX 임포트 옵션 설정
+        self._set_import_options(inImportMode, inUpAxis)
+        
+        # 임포트 실행
+        importerPlugin = rt.importerPlugin
+        result = rt.importFile(
+            str(filePath),
+            rt.Name("noPrompt"),
+            using=importerPlugin.classes[importClassIndex - 1]  # 0-based index로 변환
+        )
+        
+        return result
+    
+    def reset_import_options(self):
+        """FBX 임포트 옵션을 기본값으로 리셋"""
+        rt.FBXImporterSetParam("ResetImport")

pyjallib/max/groinBone.py

@@ -110,7 +110,7 @@ class GroinBone:
         lThighTwistHelperName = self.name.replace_name_part("Index", lThighTwistHelperName, "0")
         lThighTwistHelper = self.helper.create_point(lThighTwistHelperName)
         lThighTwistHelper.transform = pelvisHelper.transform
-        lThighTwistHelper.position = inLThighTwist.position
+        lThighTwistHelper.position = inLThighTwist.transform.position
         lThighTwistHelper.parent = inLThighTwist
         self.helper.set_shape_to_box(lThighTwistHelper)
         
@@ -119,7 +119,7 @@ class GroinBone:
         rThighTwistHelperName = self.name.replace_name_part("Index", rThighTwistHelperName, "0")
         rThighTwistHelper = self.helper.create_point(rThighTwistHelperName)
         rThighTwistHelper.transform = pelvisHelper.transform
-        rThighTwistHelper.position = inRThighTwist.position
+        rThighTwistHelper.position = inRThighTwist.transform.position
         rThighTwistHelper.parent = inRThighTwist
         self.helper.set_shape_to_box(rThighTwistHelper)
         
@@ -193,4 +193,4 @@ class GroinBone:
         inLThighTwist = sourceBones[1]
         inRThighTwist = sourceBones[2]
         
-        return self.create_bone(inPelvis, inLThighTwist, inRThighTwist, pelvisWeight, thighWeight)
+        return self.create_bone(inPelvis, inLThighTwist, inRThighTwist, inPelvisWeight=pelvisWeight, inThighWeight=thighWeight)

pyjallib/max/header.py

@@ -33,6 +33,11 @@ from .hip import Hip
 
 from .morph import Morph
 
+from .rootMotion import RootMotion
+
+from .fbxHandler import FBXHandler
+from .toolManager import ToolManager
+
 class Header:
     """
     JalLib.max 패키지의 헤더 모듈
@@ -79,7 +84,11 @@ class Header:
         
         self.morph = Morph()
         
-        self.tools = []
+        self.rootMotion = RootMotion(nameService=self.name, animService=self.anim, constraintService=self.constraint, helperService=self.helper, bipService=self.bip)
+        
+        self.fbx = FBXHandler()
+        
+        self.toolManager = ToolManager()
     
     def update_nameConifg(self, configPath):
         """
@@ -89,18 +98,6 @@ class Header:
             configPath: ConfigPath 인스턴스
         """
         self.name.load_from_config_file(configPath)
-    
-    def add_tool(self, tool):
-        """
-        도구를 추가합니다.
-        
-        Args:
-            tool: 추가할 도구
-        """
-        if tool in self.tools:
-            self.tools.remove(tool)
-        
-        self.tools.append(tool)
 
 # 모듈 레벨에서 전역 인스턴스 생성
 _pyjallibmaxheader = Header.get_instance()

pyjallib/max/hip.py

@@ -177,7 +177,7 @@ class Hip:
         self.helpers.append(thighPosHelper)
         self.helpers.append(thighRotRootHelper)
     
-    def assing_constraint(self, inCalf, inPelvisWeight=0.6, inThighWeight=0.4, inPushAmount=5.0):
+    def assing_constraint(self, inCalf, inPelvisWeight=60.0, inThighWeight=40.0, inPushAmount=5.0):
         self.calf = inCalf
         self.pelvisWeight = inPelvisWeight
         self.thighWeight = inThighWeight
@@ -188,8 +188,8 @@ class Hip:
         distanceDir = -1.0 if rt.dot(inObjXAxisVec, facingDirVec) > 0 else 1.0
         
         rotConst = self.const.assign_rot_const_multi(self.thighRotHelper, [self.pelvisHelper, self.thighTwistHelper])
-        rotConst.setWeight(1, self.pelvisWeight * 100.0)
-        rotConst.setWeight(2, self.thighWeight * 100.0)
+        rotConst.setWeight(1, self.pelvisWeight)
+        rotConst.setWeight(2, self.thighWeight)
         
         localRotRefTm = self.thighRotHelper.transform * rt.inverse(self.thighRotRootHelper.transform)
         posConst = self.const.assign_pos_script_controller(self.thighPosHelper)
@@ -200,7 +200,7 @@ class Hip:
         posConst.setExpression(self.posScriptExpression)
         posConst.update()
         
-    def create_bone(self, inPelvis, inThigh, inThighTwist, inCalf, pushAmount=5.0, inPelvisWeight=0.6, inThighWeight=0.4):
+    def create_bone(self, inPelvis, inThigh, inThighTwist, inCalf, pushAmount=5.0, inPelvisWeight=60.0, inThighWeight=40.0):
         if not rt.isValidNode(inPelvis) or not rt.isValidNode(inThigh) or not rt.isValidNode(inThighTwist):
             return False
         

pyjallib/max/kneeBone.py

@@ -66,6 +66,7 @@ class KneeBone:
         self.calfTwistHelpers = []
         
         self.middleBones = []
+        self.middleHelper = None
         
         self.liftScale = 0.05
         
@@ -177,7 +178,7 @@ class KneeBone:
         
         calfRotRootHelper = self.helper.create_point(calfRotRootHelperName, crossToggle=False, boxToggle=True)
         calfRotRootHelper.transform = inCalf.transform
-        calfRotRootHelper.position = inFoot.position
+        calfRotRootHelper.position = inFoot.transform.position
         calfRotRootHelper.parent = inCalf
         
         self.thighRotRootHelper = thighRotRootHelper
@@ -275,7 +276,7 @@ class KneeBone:
         
         self.const.set_rot_controllers_weight_in_list(self.calfRotHelper, 1, self.liftScale * 100.0)
         
-    def create_middle_bone(self, inThigh, inCalf, inKneePopScale=0.1, inKneeBackScale=1.5):
+    def create_middle_bone(self, inThigh, inCalf, inKneeVolumeSize=5.0, inKneePopScale=0.1, inKneeBackScale=1.5):
         """
         무릎 중간 본을 생성합니다.
         
@@ -292,7 +293,7 @@ class KneeBone:
             bool: 중간 본 생성 성공 여부
         """
         if not rt.isValidNode(inThigh) or not rt.isValidNode(inCalf):
-            return False
+            return None
         
         facingDirVec = inCalf.transform.position - inThigh.transform.position
         inObjXAxisVec = inCalf.objectTransform.row1
@@ -309,7 +310,7 @@ class KneeBone:
             transScales.append(inKneeBackScale)
             transScales.append(inKneePopScale)
         
-        result = self.volumeBone.create_bones(self.calf, self.thigh, inVolumeSize=5.0, inRotAxises=["Z", "Z"], inTransAxises=["PosY", "NegY"], inTransScales=transScales)
+        result = self.volumeBone.create_bones(self.calf, self.thigh, inVolumeSize=inKneeVolumeSize, inRotAxises=["Z", "Z"], inTransAxises=["PosY", "NegY"], inTransScales=transScales)
         
         filteringChar = self.name._get_filtering_char(inCalf.name)
         calfName = self.name.get_RealName(inCalf.name)
@@ -320,15 +321,16 @@ class KneeBone:
             replaceName = replaceName.lower()
             calfName = calfName.lower()
         
-        for item in result["Bones"]:
+        for item in result.bones:
             item.name = item.name.replace(calfName, replaceName)
         
-        result["RootBone"].name = result["RootBone"].name.replace(calfName, replaceName)
-        result["RotHelper"].name = result["RotHelper"].name.replace(calfName, replaceName)
+        result.bones[0].name = result.bones[0].name.replace(calfName, replaceName)
+        result.helpers[0].name = result.helpers[0].name.replace(calfName, replaceName)
         
-        # 결과 저장
-        if result and "Bones" in result:
-            self.middleBones.extend(result["Bones"])
+        # 결과 저장 - 기존 확장 방식에서 직접 할당으로 변경
+        if result.bones:
+            self.middleBones = result.bones
+            self.middleHelper = result.helpers[0]
         
         return result
     
@@ -424,7 +426,7 @@ class KneeBone:
             self.calfTwistBones.append(liftTwistBone)
             self.calfTwistHelpers.append(liftTwistHelper)
             
-    def create_bone(self, inThigh, inCalf, inFoot, inLiftScale=0.05, inKneePopScale=0.1, inKneeBackScale=1.5):
+    def create_bone(self, inThigh, inCalf, inFoot, inLiftScale=0.05, inKneeVolumeSize=5.0, inKneePopScale=0.1, inKneeBackScale=1.5):
         """
         자동 무릎 본 시스템의 모든 요소를 생성하는 주요 메서드입니다.
         
@@ -448,27 +450,48 @@ class KneeBone:
             BoneChain: 생성된 자동 무릎 본 체인 객체
         """
         if not rt.isValidNode(inThigh) or not rt.isValidNode(inCalf) or not rt.isValidNode(inFoot):
-            return False
+            return None
         
         self.create_lookat_helper(inThigh, inFoot)
         self.create_rot_root_heleprs(inThigh, inCalf, inFoot)
         self.create_rot_helper(inThigh, inCalf, inFoot)
         self.assign_thigh_rot_constraint(inLiftScale=inLiftScale)
         self.assign_calf_rot_constraint(inLiftScale=inLiftScale)
-        self.create_middle_bone(inThigh, inCalf, inKneePopScale=inKneePopScale, inKneeBackScale=inKneeBackScale)
+        self.create_middle_bone(inThigh, inCalf, inKneeVolumeSize=inKneeVolumeSize, inKneePopScale=inKneePopScale, inKneeBackScale=inKneeBackScale)
         self.create_twist_bones(inThigh, inCalf)
         
-        # 모든 생성된 본들 수집
-        all_bones = self.thighTwistBones + self.calfTwistBones + self.middleBones
+        # 모든 생성된 본들을 개별적으로 수집
+        all_bones = []
+        
+        # 대퇴부 트위스트 본 추가
+        for bone in self.thighTwistBones:
+            all_bones.append(bone)
+            
+        # 종아리 트위스트 본 추가
+        for bone in self.calfTwistBones:
+            all_bones.append(bone)
+            
+        # 중간 본 추가
+        for bone in self.middleBones:
+            all_bones.append(bone)
+        
+        # 모든 헬퍼 수집
         all_helpers = [self.lookAtHleper, self.thighRotHelper, self.calfRotHelper, 
-                      self.thighRotRootHelper, self.calfRotRootHelper] + self.thighTwistHelpers + self.calfTwistHelpers
+                      self.thighRotRootHelper, self.calfRotRootHelper, self.middleHelper]
+                      
+        # 트위스트 헬퍼 추가
+        for helper in self.thighTwistHelpers:
+            all_helpers.append(helper)
+            
+        for helper in self.calfTwistHelpers:
+            all_helpers.append(helper)
         
         # 결과를 BoneChain 형태로 준비
         result = {
             "Bones": all_bones,
             "Helpers": all_helpers,
             "SourceBones": [inThigh, inCalf, inFoot],
-            "Parameters": [inLiftScale, inKneePopScale, inKneeBackScale]
+            "Parameters": [inLiftScale, inKneeVolumeSize, inKneePopScale, inKneeBackScale]
         }
         
         # 메소드 호출 후 데이터 초기화
@@ -503,8 +526,9 @@ class KneeBone:
             
         # 파라미터 가져오기 (또는 기본값 사용)
         liftScale = parameters[0] if len(parameters) > 0 else 0.05
-        kneePopScale = parameters[1] if len(parameters) > 1 else 0.1
-        kneeBackScale = parameters[2] if len(parameters) > 2 else 1.5
+        kneeVolumeSize = parameters[1] if len(parameters) > 1 else 5.0
+        kneePopScale = parameters[2] if len(parameters) > 2 else 0.1
+        kneeBackScale = parameters[3] if len(parameters) > 3 else 1.5
         
         # 무릎 본 생성
         inThigh = sourceBones[0]
@@ -512,7 +536,7 @@ class KneeBone:
         inFoot = sourceBones[2]
         
         # 새로운 자동 무릎 본 생성
-        return self.create_bone(inThigh, inCalf, inFoot, liftScale, kneePopScale, kneeBackScale)
+        return self.create_bone(inThigh, inCalf, inFoot, liftScale, kneeVolumeSize, kneePopScale, kneeBackScale)
     
     def reset(self):
         """

pyjallib/max/layer.py

@@ -66,12 +66,18 @@ class Layer:
             레이어에 포함된 노드 배열 또는 빈 배열
         """
         returnVal = []
-        layer = rt.ILayerManager.getLayerObject(inLayerNum)
-        if layer is not None:
-            layerNodes = rt.refs.dependents(layer)
-            for item in layerNodes:
-                if rt.isValidNode(item):
-                    returnVal.append(item)
+        
+        code = f"""
+        layer = layermanager.getLayer {inLayerNum}
+        layer.nodes &theNodes
+        theNodes
+        """
+
+        nodes = rt.execute(code)
+        
+        for item in nodes:
+            if rt.isValidNode(item):
+                returnVal.append(item)
                     
         return returnVal