pyjallib 0.1.17__tar.gz → 0.1.19__tar.gz

{pyjallib-0.1.17 → pyjallib-0.1.19}/PKG-INFO

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

{pyjallib-0.1.17 → pyjallib-0.1.19}/pyproject.toml

@@ -1,21 +1,21 @@
-[project]
-name = "pyjallib"
-version = "0.1.17"
-description = "A utility library for 3D game character development pipelines."
-readme = "README.md"
-authors = [
-    { name = "Dongseok Kim", email = "jalnagakds@gmail.com" }
-]
-requires-python = ">=3.10"
-dependencies = [
-    "p4python>=2024.2.2682690",
-]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.pdoc]
-modules = ["pyjallib"]
-output_directory = "docs"
-docformat = "markdown"
+[project]
+name = "pyjallib"
+version = "0.1.19"
+description = "A utility library for 3D game character development pipelines."
+readme = "README.md"
+authors = [
+    { name = "Dongseok Kim", email = "jalnagakds@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "p4python>=2024.2.2682690",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pdoc]
+modules = ["pyjallib"]
+output_directory = "docs"
+docformat = "markdown"

{pyjallib-0.1.17 → pyjallib-0.1.19}/src/pyjallib/__init__.py

@@ -6,14 +6,15 @@ pyjallib Package
 Python library for game character development pipeline.
 """
 
-__version__ = '0.1.17'
+__version__ = '0.1.19'
 
 # reload_modules 함수를 패키지 레벨에서 사용 가능하게 함
+from pyjallib.logger import Logger
+from pyjallib.progressEvent import ProgressEvent
+from pyjallib.exceptions import PyJalLibError, PerforceError, ValidationError, FileOperationError, NamingConfigError, MaxError, UE5Error
 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
-from pyjallib.logger import Logger
-from pyjallib.progressEvent import ProgressEvent
+from pyjallib.reloadModules import reload_modules

pyjallib-0.1.19/src/pyjallib/exceptions.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+PyJalLib 커스텀 예외 클래스들
+라이브러리에서 발생할 수 있는 다양한 예외 상황을 명확히 구분하기 위한 예외 클래스 정의
+"""
+
+import inspect
+from typing import Optional
+
+
+class PyJalLibError(Exception):
+    """PyJalLib 기본 예외 클래스"""
+    
+    def __init__(self, inMessage: str, inFunctionName: Optional[str] = None):
+        """
+        Args:
+            inMessage (str): 에러 메시지
+            inFunctionName (str, optional): 에러가 발생한 함수명. None인 경우 자동으로 감지 시도
+        """
+        self.function_name = inFunctionName or self._get_caller_function_name()
+        super().__init__(inMessage)
+    
+    def _get_caller_function_name(self) -> Optional[str]:
+        """호출자 함수명을 자동으로 감지"""
+        try:
+            # 현재 스택에서 호출자 함수명 찾기
+            frame = inspect.currentframe()
+            if frame and frame.f_back and frame.f_back.f_back:
+                return frame.f_back.f_back.f_code.co_name
+        except Exception:
+            pass
+        return None
+    
+    def get_function_name(self) -> Optional[str]:
+        """에러가 발생한 함수명 반환"""
+        return self.function_name
+    
+    def __str__(self) -> str:
+        """에러 메시지 반환 (함수명 포함)"""
+        message = super().__str__()
+        if self.function_name:
+            return f"[{self.function_name}] {message}"
+        return message
+
+
+class PerforceError(PyJalLibError):
+    """Perforce 관련 예외"""
+    pass
+
+
+class ValidationError(PyJalLibError):
+    """입력값 검증 실패 예외"""
+    pass
+
+
+class FileOperationError(PyJalLibError):
+    """파일 작업 실패 예외"""
+    pass
+
+
+class NamingConfigError(PyJalLibError):
+    """NamingConfig 관련 예외"""
+    pass
+
+
+class MaxError(PyJalLibError):
+    """3ds Max 관련 예외"""
+    pass
+
+
+class UE5Error(PyJalLibError):
+    """UE5 관련 예외"""
+    pass 

pyjallib-0.1.19/src/pyjallib/logger.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+PyJalLib 중앙 집중식 로깅 모듈
+모든 PyJalLib 모듈에서 사용할 수 있는 통합 로깅 시스템을 제공합니다.
+"""
+
+import logging
+import inspect
+import sys
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+from pyjallib.exceptions import PyJalLibError
+
+
+class Logger:
+    """PyJalLib 간단한 로깅 클래스"""
+    
+    def __init__(self, inLogPath: Optional[str] = None, inLogFileName: Optional[str] = None, 
+                 inEnableConsole: bool = True, inLogLevel: str = "debug"):
+        """로거 인스턴스 초기화
+        
+        Args:
+            inLogPath (str, optional): 로그 파일 저장 경로. 
+                                     None인 경우 기본 경로 사용 (Documents/PyJalLib/logs)
+            inLogFileName (str, optional): 로그 파일명 (확장자 제외). 
+                                         None인 경우 기본값 "pyjallib" 사용
+                                         실제 파일명은 "YYYYMMDD_파일명.log" 형식으로 생성
+            inEnableConsole (bool): 콘솔 출력 활성화 여부 (기본값: True)
+            inLogLevel (str): 로깅 레벨 (debug, info, warning, error, critical). 기본값: "debug"
+        """
+        # 기본 로그 경로 설정
+        if inLogPath is None:
+            documents_path = Path.home() / "Documents"
+            self._logPath = documents_path / "PyJalLib" / "logs"
+        else:
+            self._logPath = Path(inLogPath)
+            
+        # 로그 디렉토리 생성
+        self._logPath.mkdir(parents=True, exist_ok=True)
+        
+        # 로그 파일명 설정 (확장자 제외)
+        self._logFileName = inLogFileName if inLogFileName is not None else "pyjallib"
+        
+        # 출력 옵션 설정
+        self._enableConsole = inEnableConsole
+        self._sessionName = None  # 초기에는 세션 없음
+        
+        # 로깅 레벨 설정
+        self._logLevel = self._parse_log_level(inLogLevel)
+        
+        # 로거 생성 및 설정
+        self._logger = logging.getLogger(f"pyjallib_{id(self)}")
+        self._logger.setLevel(self._logLevel)
+        self._logger.handlers.clear()  # 기존 핸들러 제거
+        self._setup_handlers()
+    
+    def _parse_log_level(self, inLogLevel: str) -> int:
+        """문자열 로깅 레벨을 logging 상수로 변환
+        
+        Args:
+            inLogLevel (str): 로깅 레벨 문자열
+            
+        Returns:
+            int: logging 모듈의 레벨 상수
+        """
+        level_map = {
+            "debug": logging.DEBUG,
+            "info": logging.INFO,
+            "warning": logging.WARNING,
+            "error": logging.ERROR,
+            "critical": logging.CRITICAL
+        }
+        
+        level_str = inLogLevel.lower().strip()
+        if level_str in level_map:
+            return level_map[level_str]
+        else:
+            # 잘못된 레벨이 입력된 경우 기본값으로 DEBUG 사용
+            return logging.DEBUG
+    
+    def _generate_auto_message(self, inLevel: str) -> str:
+        """자동 메시지 생성
+        
+        Args:
+            inLevel (str): 로깅 레벨 문자열
+            
+        Returns:
+            str: 자동 생성된 메시지
+        """
+        # 호출자 함수명 감지 (2단계 위: _generate_auto_message <- debug/info/etc <- 실제 호출자)
+        try:
+            caller_frame = inspect.currentframe().f_back.f_back
+            function_name = caller_frame.f_code.co_name
+            filename = caller_frame.f_code.co_filename
+            line_number = caller_frame.f_lineno
+            
+            # 파일명에서 경로 제거하고 확장자만 유지
+            file_basename = Path(filename).name
+        except (AttributeError, TypeError):
+            function_name = "unknown"
+            file_basename = "unknown"
+            line_number = 0
+        
+        # 현재 예외 정보 확인
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        
+        if exc_value:
+            # 예외가 활성화된 상태라면 예외 정보 포함
+            return f"[{file_basename}:{line_number}:{function_name}] {exc_type.__name__}: {exc_value}"
+        else:
+            # 예외가 없다면 기본 메시지
+            return f"[{file_basename}:{line_number}:{function_name}] {inLevel.upper()} 로그"
+    
+    def debug(self, inMessage: Optional[str] = None) -> None:
+        """디버그 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("debug")
+        self._logger.debug(inMessage)
+        
+    def info(self, inMessage: Optional[str] = None) -> None:
+        """정보 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("info")
+        self._logger.info(inMessage)
+        
+    def warning(self, inMessage: Optional[str] = None) -> None:
+        """경고 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("warning")
+        self._logger.warning(inMessage)
+        
+    def error(self, inMessage: Optional[str] = None) -> None:
+        """에러 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("error")
+        self._logger.error(inMessage)
+        
+    def critical(self, inMessage: Optional[str] = None) -> None:
+        """치명적 에러 레벨 로그 메시지
+        
+        Args:
+            inMessage (str, optional): 로그 메시지. None인 경우 자동 생성
+        """
+        if inMessage is None:
+            inMessage = self._generate_auto_message("critical")
+        self._logger.critical(inMessage)
+        
+    def set_session(self, inSessionName: str) -> None:
+        """새로운 로깅 세션 설정 및 시작
+        
+        Args:
+            inSessionName (str): 세션 구분용 이름
+        """
+        # 기존 세션이 있다면 종료
+        if self._sessionName is not None:
+            self.end_session()
+            
+        # 새 세션 시작
+        self._sessionName = inSessionName
+        separator_msg = f"===== {self._sessionName} 로깅 시작 ====="
+        self._log_separator(separator_msg)
+        
+    def end_session(self) -> None:
+        """현재 로깅 세션 종료 구분선 출력"""
+        if self._sessionName is not None:
+            separator_msg = f"===== {self._sessionName} 로깅 끝 ====="
+            self._log_separator(separator_msg)
+            self._sessionName = None
+            
+    def close(self) -> None:
+        """로거 핸들러들을 명시적으로 닫기"""
+        for handler in self._logger.handlers[:]:
+            try:
+                handler.close()
+                self._logger.removeHandler(handler)
+            except Exception:
+                pass
+    
+    def log_exception(self, inException: Exception, inCustomMessage: Optional[str] = None) -> None:
+        """예외 정보를 로그에 기록
+        
+        Args:
+            inException (Exception): 기록할 예외 객체
+            inCustomMessage (str, optional): 사용자 정의 메시지. None인 경우 예외 메시지만 기록
+        """
+        if inCustomMessage:
+            message = f"{inCustomMessage}: {inException}"
+        else:
+            message = str(inException)
+        
+        self._logger.error(message)
+    
+    def log_pyjallib_error(self, inError: PyJalLibError, inCustomMessage: Optional[str] = None) -> None:
+        """PyJalLib 예외를 로그에 기록 (함수명 포함)
+        
+        Args:
+            inError (PyJalLibError): PyJalLib 예외 객체
+            inCustomMessage (str, optional): 사용자 정의 메시지
+        """
+        # PyJalLibError는 이미 함수명이 포함된 메시지를 반환
+        if inCustomMessage:
+            message = f"{inCustomMessage}: {inError}"
+        else:
+            message = str(inError)
+        
+        self._logger.error(message)
+    
+    def log_function_error(self, inFunctionName: str, inMessage: str) -> None:
+        """함수명을 포함한 에러 메시지를 로그에 기록
+        
+        Args:
+            inFunctionName (str): 함수명
+            inMessage (str): 에러 메시지
+        """
+        message = f"[{inFunctionName}] {inMessage}"
+        self._logger.error(message)
+        
+    def _log_separator(self, inMessage: str) -> None:
+        """구분선 메시지를 모든 핸들러에 직접 출력"""
+        # 구분선은 INFO 레벨로 출력하되, 특별한 포맷 사용
+        separator_record = logging.LogRecord(
+            name=self._logger.name,
+            level=logging.INFO,
+            pathname="",
+            lineno=0,
+            msg=inMessage,
+            args=(),
+            exc_info=None
+        )
+        
+        # 각 핸들러에 직접 전송 (포맷터 우회)
+        for handler in self._logger.handlers:
+            try:
+                # 핸들러 레벨 확인
+                if handler.level <= logging.INFO:
+                    # 구분선만 특별한 포맷으로 출력
+                    if hasattr(handler, 'stream'):
+                        handler.stream.write(inMessage + "\n")
+                        if hasattr(handler, 'flush'):
+                            handler.flush()
+            except Exception:
+                # 핸들러 오류 시 무시
+                pass
+        
+    def _setup_handlers(self) -> None:
+        """로거에 핸들러 설정"""
+        # 파일 핸들러 (항상 활성화) - 날짜 기반 파일명
+        current_date = datetime.now().strftime("%Y%m%d")
+        log_filename = f"{self._logFileName}_{current_date}.log"
+        log_file = self._logPath / log_filename
+        file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setLevel(self._logLevel)  # 파일 핸들러도 동일한 레벨 적용
+        file_handler.setFormatter(self._get_formatter())
+        self._logger.addHandler(file_handler)
+        
+        # 콘솔 핸들러 (선택사항)
+        if self._enableConsole:
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(self._logLevel)  # 콘솔 핸들러도 동일한 레벨 적용
+            console_handler.setFormatter(self._get_formatter())
+            self._logger.addHandler(console_handler)
+            
+    def _get_formatter(self) -> logging.Formatter:
+        """표준 포맷터 반환"""
+        return logging.Formatter(
+            '%(asctime)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        ) 

{pyjallib-0.1.17 → pyjallib-0.1.19}/src/pyjallib/max/__init__.py

@@ -32,7 +32,11 @@ from pyjallib.max.boneChain import BoneChain
 from pyjallib.max.twistBone import TwistBone
 from pyjallib.max.groinBone import GroinBone
 from pyjallib.max.autoClavicle import AutoClavicle
+from pyjallib.max.shoulder import Shoulder
 from pyjallib.max.volumeBone import VolumeBone
+from pyjallib.max.elbow import Elbow
+from pyjallib.max.wrist import Wrist
+from pyjallib.max.inguinal import Inguinal
 from pyjallib.max.kneeBone import KneeBone
 from pyjallib.max.hip import Hip
 
@@ -65,7 +69,11 @@ __all__ = [
     'TwistBone',
     'GroinBone',
     'AutoClavicle',
+    'Shoulder',
     'VolumeBone',
+    'Elbow',
+    'Wrist',
+    'Inguinal',
     'KneeBone',
     'Hip',
     'RootMotion',

{pyjallib-0.1.17 → pyjallib-0.1.19}/src/pyjallib/max/autoClavicle.py

@@ -48,6 +48,10 @@ class AutoClavicle:
         self.bip = bipService if bipService else Bip(nameService=self.name, animService=self.anim)
         
         self.boneSize = 2.0
+        self.rotTargetUpperArmPosConstExpression = ""
+        self.rotTargetUpperArmPosConstExpression += "local clavicleDistance = distance clavicle upperArm\n"
+        self.rotTargetUpperArmPosConstExpression += "local xPos = (clavicleDistance/2.0) * distanceDir * liftScale\n"
+        self.rotTargetUpperArmPosConstExpression += "[xPos, 0.0, 0.0]\n"
         
         # 초기화된 결과를 저장할 변수들
         self.genBones = []
@@ -106,37 +110,43 @@ class AutoClavicle:
         autoClavicleBone = self.bone.create_nub_bone(autoClavicleName, 2)
         autoClavicleBone.name = self.name.remove_name_part("Nub", autoClavicleBone.name)
         autoClavicleBone.transform = inClavicle.transform
-        self.anim.move_local(autoClavicleBone, clavicleLength/2.0, 0.0, 0.0)
         autoClavicleBone.parent = inClavicle
+        autoClvaiclePosConst = self.const.assign_pos_const_multi(autoClavicleBone, [inClavicle, inUpperArm])
         genBones.append(autoClavicleBone)
         
         # 타겟 헬퍼 포인트 생성 (쇄골과 상완용)
         rotTargetClavicle = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Target")))
         rotTargetClavicle.name = self.name.replace_name_part("Index", rotTargetClavicle.name, "0")
         rotTargetClavicle.transform = inClavicle.transform
-        self.anim.move_local(rotTargetClavicle, clavicleLength, 0.0, 0.0)
-        
         rotTargetClavicle.parent = inClavicle
+        rotTargetClaviclePosConst = self.const.assign_pos_const(rotTargetClavicle, inUpperArm)
         genHelpers.append(rotTargetClavicle)
         
         rotTargetUpperArm = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Target")))
         rotTargetUpperArm.name = self.name.add_suffix_to_real_name(rotTargetUpperArm.name, self.name._get_filtering_char(inClavicle.name) + "arm")
         rotTargetUpperArm.transform = inUpperArm.transform
-        self.anim.move_local(rotTargetUpperArm, (clavicleLength/2.0)*liftScale, 0.0, 0.0)
-        
         rotTargetUpperArm.parent = inUpperArm
+        rotTargetUpperArmPosConst = self.const.assign_pos_script_controller(rotTargetUpperArm)
+        rotTargetUpperArmPosConst.addConstant("distanceDir", distanceDir)
+        rotTargetUpperArmPosConst.addConstant("liftScale", liftScale)
+        rotTargetUpperArmPosConst.addNode("clavicle", inClavicle)
+        rotTargetUpperArmPosConst.addNode("upperArm", inUpperArm)
+        rotTargetUpperArmPosConst.setExpression(self.rotTargetUpperArmPosConstExpression)
         genHelpers.append(rotTargetUpperArm)
         
         # 회전 헬퍼 포인트 생성
         autoClavicleRotHelper = self.helper.create_point(self.name.replace_name_part("Type", autoClavicleName, self.name.get_name_part_value_by_description("Type", "Rotation")))
         autoClavicleRotHelper.transform = autoClavicleBone.transform
         autoClavicleRotHelper.parent = inClavicle
+        autoClavicleRotHelperPosConst = self.const.assign_pos_const_multi(autoClavicleRotHelper, [inClavicle, inUpperArm])
         
         lookAtConst = self.const.assign_lookat_multi(autoClavicleRotHelper, [rotTargetClavicle, rotTargetUpperArm])
         
         lookAtConst.upnode_world = False
         lookAtConst.pickUpNode = inClavicle
         lookAtConst.lookat_vector_length = 0.0
+        if distanceDir < 0:
+            lookAtConst.target_axisFlip = True
         
         genHelpers.append(autoClavicleRotHelper)
         
@@ -175,6 +185,8 @@ class AutoClavicle:
         # 메소드 호출 후 데이터 초기화
         self.reset()
         
+        rt.redrawViews()
+        
         return BoneChain.from_result(result)
     
     def create_bones_from_chain(self, inBoneChain: BoneChain):

{pyjallib-0.1.17 → pyjallib-0.1.19}/src/pyjallib/max/bone.py

@@ -976,8 +976,16 @@ class Bone:
         spineDistance = rt.distance(spine3, neck)/3.0
         rt.setProperty(spine4, "transform", spine3.transform)
         rt.setProperty(spine5, "transform", spine3.transform)
+        
         self.anim.move_local(spine4, spineDistance, 0, 0)
+        spine4PosConst = self.const.assign_pos_const_multi(spine4, [spine3, neck])
+        spine4PosConst.setWeight(1, 100.0*(2.0/3.0))
+        spine4PosConst.setWeight(2, 100.0 - (100.0*(2.0/3.0)))
+        
         self.anim.move_local(spine5, spineDistance * 2, 0, 0)
+        spine5PosConst = self.const.assign_pos_const_multi(spine5, [spine3, neck])
+        spine5PosConst.setWeight(1, 100.0*(1.0/3.0))
+        spine5PosConst.setWeight(2, 100.0 - (100.0*(1.0/3.0)))
         
         returnBones.append(spine4)
         returnBones.append(spine5)
@@ -995,6 +1003,7 @@ class Bone:
         neckDistance = rt.distance(neck, head)/2.0
         rt.setProperty(nekc2, "transform", neck.transform)
         self.anim.move_local(nekc2, neckDistance, 0, 0)
+        neck2PosConst = self.const.assign_pos_const_multi(nekc2, [neck, head])
         
         returnBones.append(nekc2)
         
@@ -1338,4 +1347,15 @@ class Bone:
         """
         selArray = list(rt.getCurrentSelection())
         for item in selArray:
-            self.set_freeze_length_off(item)
+            self.set_freeze_length_off(item)
+            
+    def turn_bone(self, inBone, inAngle):
+        """
+        입력된 각도만큼 입력된 본의 로컬 X 축을 회전 합니다.
+        
+        Args:
+            inBone: 회전할 뼈대 객체
+            inAngle: 회전할 각도
+        """
+        if rt.classOf(inBone) == rt.BoneGeometry:
+            self.anim.rotate_local(inBone, inAngle, 0, 0, dontAffectChildren=True)

{pyjallib-0.1.17 → pyjallib-0.1.19}/src/pyjallib/max/boneChain.py

@@ -92,6 +92,8 @@ class BoneChain:
             self.bones = []
             self.helpers = []
             
+            rt.redrawViews()
+            
             return True
         except:
             return False

{pyjallib-0.1.17 → pyjallib-0.1.19}/src/pyjallib/max/constraint.py

@@ -32,7 +32,7 @@ class Constraint:
         self.name = nameService if nameService else Name()
         self.helper = helperService if helperService else Helper(nameService=self.name) # Pass the potentially newly created nameService
     
-    def collapse(self, inObj):
+    def collapse(self, inObj, inUseTCBRot=False):
         """
         비 Biped 객체의 트랜스폼 컨트롤러를 기본 컨트롤러로 초기화하고 현재 변환 상태 유지.
         
@@ -48,7 +48,10 @@ class Constraint:
             
             # 기본 컨트롤러로 위치, 회전, 스케일 초기화
             rt.setPropertyController(inObj.controller, "Position", rt.Position_XYZ())
-            rt.setPropertyController(inObj.controller, "Rotation", rt.Euler_XYZ())
+            if inUseTCBRot:
+                rt.setPropertyController(inObj.controller, "Rotation", rt.TCB_Rotation())
+            else:
+                rt.setPropertyController(inObj.controller, "Rotation", rt.Euler_XYZ())
             rt.setPropertyController(inObj.controller, "Scale", rt.Bezier_Scale())
             
             # 백업한 변환 상태 복원
@@ -473,6 +476,28 @@ class Constraint:
         
         return eulerXYZ
     
+    def assign_tcb_rot(self, inObj):
+        """
+        객체에 TCB 회전 컨트롤러를 할당.
+        
+        Args:
+            inObj: 컨트롤러를 할당할 객체
+        """
+        # 회전 컨트롤러가 리스트 형태가 아니면 변환
+        rot_controller = rt.getPropertyController(inObj.controller, "Rotation")
+        if rt.classOf(rot_controller) != rt.Rotation_list:
+            rt.setPropertyController(inObj.controller, "Rotation", rt.Rotation_list())
+            
+        # 회전 리스트 컨트롤러 가져오기
+        rotList = self.assign_rot_list(inObj)
+        
+        # TCB 회전 컨트롤러 할당
+        tcbRot = rt.TCB_Rotation()
+        rt.setPropertyController(rotList, "Available", tcbRot)
+        rotList.setActive(rotList.count)
+        
+        return tcbRot
+    
     def get_lookat(self, inObj):
         """
         객체의 LookAt 제약 컨트롤러를 찾아 반환.