pyjallib 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

pyjallib/ue5/inUnreal/animationImporter.py

@@ -26,7 +26,31 @@ class AnimationImporter(BaseImporter):
     def asset_type(self) -> str:
         return "Animation"
     
-    def _create_import_task(self, inFbxFile: str, inDestinationPath: str, inFbxSkeletonPath: str):
+    def _create_batch_import_description(self, inFbxFiles: list[str], inAssetFullPaths: list[str]) -> str:
+        """
+        배치 임포트용 간결한 디스크립션 생성
+        
+        Args:
+            inFbxFiles (list[str]): 임포트된 FBX 파일 목록
+            inAssetFullPaths (list[str]): 임포트된 에셋 전체 경로 목록
+            
+        Returns:
+            str: 간결한 디스크립션
+        """
+        totalCount = len(inFbxFiles)
+        
+        if totalCount <= 3:
+            # 3개 이하면 모든 경로 표시
+            fbxList = ", ".join(inFbxFiles)
+            assetList = ", ".join(inAssetFullPaths)
+            return f"Animation Batch Import ({totalCount} files): {fbxList} -> {assetList}"
+        else:
+            # 3개 초과면 처음 3개만 표시하고 나머지는 개수로 표시
+            fbxList = ", ".join(inFbxFiles[:3]) + f" ... (and {totalCount - 3} more)"
+            assetList = ", ".join(inAssetFullPaths[:3]) + f" ... (and {totalCount - 3} more)"
+            return f"Animation Batch Import ({totalCount} files): {fbxList} -> {assetList}"
+    
+    def create_import_task(self, inFbxFile: str, inDestinationPath: str, inFbxSkeletonPath: str):
         """애니메이션 임포트를 위한 태스크 생성 - 스켈레톤 필수 지정"""
         ue5_logger.debug(f"애니메이션 임포트 태스크 생성 시작: {inFbxFile}")
         
@@ -75,7 +99,7 @@ class AnimationImporter(BaseImporter):
         if unreal.Paths.file_exists(assetFullPath):
             unreal.SourceControl.check_out_or_add_file(assetFullPath, silent=True)
         
-        task = self._create_import_task(inFbxFile, destinationPath, inFbxSkeletonPath)
+        task = self.create_import_task(inFbxFile, destinationPath, inFbxSkeletonPath)
         
         ue5_logger.info(f"애니메이션 임포트 실행: {inFbxFile} -> {destinationPath}/{assetName}")
         unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
@@ -86,29 +110,97 @@ class AnimationImporter(BaseImporter):
             ue5_logger.error(error_msg)
             raise ValueError(error_msg)
         
-        # 임포트된 애니메이션 에셋의 시스템 경로 가져오기
-        importedAnimation = None
-        for asset in result:
-            if isinstance(asset, unreal.AnimSequence):
-                importedAnimation = asset
-                break
-        
-        if importedAnimation is None:
-            error_msg = f"애니메이션 에셋을 찾을 수 없음: {inFbxFile}"
-            ue5_logger.error(error_msg)
-            raise ValueError(error_msg)
-        
-        importedObjectPaths = self.get_dirty_deps(assetFullPath)
+        importedObjectPaths = task.imported_object_paths
+        refObjectPaths = self.get_dirty_deps(assetFullPath)
         
-        animationSystemFullPath = unreal.SystemLibrary.get_system_path(importedAnimation)
-        importedObjectPaths.append(animationSystemFullPath)
+        allImportRelatedPaths = list(dict.fromkeys(importedObjectPaths + refObjectPaths))
+        for assetPath in allImportRelatedPaths:
+            unreal.SourceControl.check_out_or_add_file(assetPath, silent=True)
         
         checkInDescription = f"Animation Imported by {inFbxFile} to {assetFullPath}"
         if inDescription is not None:
             checkInDescription = inDescription
         
-        unreal.SourceControl.check_in_files(importedObjectPaths, checkInDescription, silent=True)
+        allImportAbsPaths = []
+        for assetPath in allImportRelatedPaths:
+            assetObj = unreal.EditorAssetLibrary.load_asset(assetPath)
+            if assetObj is not None:
+                absPath = unreal.SystemLibrary.get_system_path(assetObj)
+                allImportAbsPaths.append(absPath)
+        
+        unreal.SourceControl.check_in_files(allImportAbsPaths, checkInDescription, silent=True)
         
         ue5_logger.info(f"애니메이션 임포트 성공: {inFbxFile} -> {len(result)}개 객체 생성")
         return self._create_result_dict(inFbxFile, destinationPath, assetName, True) 
-        
+    
+    def import_animations(self, inFbxFiles: list[str], inFbxSkeletonPaths: list[str], inAssetNames: list[str] = None, inDescription: str = None):
+        ue5_logger.info(f"애니메이션 임포트 시작: {inFbxFiles}")
+        
+        if len(inFbxFiles) != len(inFbxSkeletonPaths):
+            error_msg = "애니메이션 임포트에는 파일과 스켈레톤이 같은 개수여야 합니다"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        if inAssetNames is not None and len(inFbxFiles) != len(inAssetNames):
+            error_msg = "애니메이션 임포트에는 파일과 에셋 이름이 같은 개수여야 합니다"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        destinationPaths = []
+        assetNames = []
+        assetFullPaths = []
+        tasks = []
+        for index, fbxFile in enumerate(inFbxFiles):
+            cusAssetName = None
+            if inAssetNames is not None:
+                cusAssetName = inAssetNames[index]
+            destinationPath, assetName = self._prepare_import_paths(fbxFile, cusAssetName)
+            
+            destinationPaths.append(destinationPath)
+            assetNames.append(assetName)
+            assetFullPath = f"{destinationPath}/{assetName}"
+            assetFullPaths.append(assetFullPath)
+            
+            if unreal.Paths.file_exists(assetFullPath):
+                unreal.SourceControl.check_out_or_add_file(assetFullPath, silent=True)
+            
+            task = self.create_import_task(fbxFile, destinationPath, inFbxSkeletonPaths[index])
+            tasks.append(task)
+        
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks(tasks)
+        
+        batchImportedAssetPaths = []
+        batchImporteAbsPaths = []
+        for index, task in enumerate(tasks):
+            result = task.get_objects()
+            if len(result) == 0:
+                error_msg = f"애니메이션 임포트 실패: {inFbxFiles[index]}"
+                ue5_logger.error(error_msg)
+                raise ValueError(error_msg)
+            
+            importedObjectPaths = task.imported_object_paths
+            refObjectPaths = self.get_dirty_deps(assetFullPaths[index])
+            
+            
+            allImportRelatedPaths = list(dict.fromkeys(importedObjectPaths + refObjectPaths))
+            for assetPath in allImportRelatedPaths:
+                unreal.SourceControl.check_out_or_add_file(assetPath, silent=True)
+                batchImportedAssetPaths.append(assetPath)
+        
+        batchImportedAssetPaths = list(dict.fromkeys(batchImportedAssetPaths))
+        for assetPath in batchImportedAssetPaths:
+            assetObj = unreal.EditorAssetLibrary.load_asset(assetPath)
+            if assetObj is not None:
+                absPath = unreal.SystemLibrary.get_system_path(assetObj)
+                batchImporteAbsPaths.append(absPath)
+            
+        # 배치 임포트용 간결한 디스크립션 생성
+        if inDescription is not None:
+            checkInDescription = inDescription
+        else:
+            checkInDescription = self._create_batch_import_description(inFbxFiles, assetFullPaths)
+        
+        checkinResult = unreal.SourceControl.check_in_files(batchImporteAbsPaths, checkInDescription, silent=True)
+        ue5_logger.info(f"배치 임포트 체크인 결과: {checkinResult}")
+        
+        ue5_logger.info(f"애니메이션 임포트 완료: {inFbxFiles}")

pyjallib/ue5/inUnreal/baseImporter.py

@@ -153,7 +153,7 @@ class BaseImporter(ABC):
         return destinationPath, assetName
     
     @abstractmethod
-    def _create_import_task(self, inFbxFile: str, inDestinationPath: str):
+    def create_import_task(self, inFbxFile: str, inDestinationPath: str):
         """임포트 태스크를 생성하는 추상 메서드 - 각 임포터에서 구현"""
         pass 
     
@@ -163,6 +163,8 @@ class BaseImporter(ABC):
         assetRegistry = unreal.AssetRegistryHelpers.get_asset_registry()
         assetData = unreal.EditorAssetLibrary.find_asset_data(inAssetPath)
         
+        ue5_logger.error(f"assetData: {assetData.asset_name}")
+        
         depPackages = assetRegistry.get_dependencies(
             assetData.package_name,  
             unreal.AssetRegistryDependencyOptions(
@@ -174,11 +176,12 @@ class BaseImporter(ABC):
             )
         )
         
-        for dep in depPackages:
-            depPathStart = str(dep).split('/')[1]
-            assetPathStart = str(assetData.package_name).split('/')[1]
-            if depPathStart == assetPathStart:
-                if unreal.EditorAssetLibrary.save_asset(dep, only_if_is_dirty=True):
-                    returnList.append(dep)
+        if depPackages is not None:
+            for dep in depPackages:
+                depPathStart = str(dep).split('/')[1]
+                assetPathStart = str(assetData.package_name).split('/')[1]
+                if depPathStart == assetPathStart:
+                    if unreal.EditorAssetLibrary.save_asset(dep, only_if_is_dirty=True):
+                        returnList.append(dep)
         
         return returnList

pyjallib/ue5/inUnreal/skeletalMeshImporter.py

@@ -25,7 +25,7 @@ class SkeletalMeshImporter(BaseImporter):
     def asset_type(self) -> str:
         return "SkeletalMesh"
     
-    def _create_import_task(self, inFbxFile: str, inDestinationPath: str, inFbxSkeletonPath: str):
+    def create_import_task(self, inFbxFile: str, inDestinationPath: str, inFbxSkeletonPath: str):
         """스켈레탈 메시 임포트를 위한 태스크 생성 - 스켈레톤 필수 지정"""
         ue5_logger.debug(f"스켈레탈 메시 임포트 태스크 생성 시작: {inFbxFile}")
         

pyjallib/ue5/inUnreal/skeletonImporter.py

@@ -26,7 +26,7 @@ class SkeletonImporter(BaseImporter):
     def asset_type(self) -> str:
         return "Skeleton"
     
-    def _create_import_task(self, inFbxFile: str, inDestinationPath: str):
+    def create_import_task(self, inFbxFile: str, inDestinationPath: str):
         """스켈레톤 임포트를 위한 태스크 생성 - 새 스켈레톤 생성"""
         ue5_logger.debug(f"스켈레톤 임포트 태스크 생성 시작: {inFbxFile}")
         

pyjallib/ue5/logger.py

@@ -3,14 +3,17 @@
 
 """
 UE5 모듈 로깅 설정 모듈
-UE5 모듈의 중앙 집중식 로깅 시스템을 관리합니다.
+메인 Logger 클래스를 상속하여 UE5 전용 기능을 추가합니다.
 """
 
 import logging
-import os
 from pathlib import Path
+from typing import Optional
 from datetime import datetime
 
+from pyjallib.logger import Logger
+
+
 class UE5LogHandler(logging.Handler):
     """UE5 전용 로그 핸들러 - UE5의 로그 시스템과 호환되도록 설계"""
     
@@ -20,75 +23,158 @@ class UE5LogHandler(logging.Handler):
             # UE5의 unreal.log 함수 사용
             import unreal
             
+            # 메시지 포맷팅
+            message = self.format(record) if self.formatter else record.getMessage()
+            
             # 로그 레벨에 따라 적절한 UE5 로그 함수 호출
             if record.levelno >= logging.ERROR:
-                unreal.log_error(f"[PyJalLib] {record.getMessage()}")
+                unreal.log_error(f"[PyJalLib] {message}")
             elif record.levelno >= logging.WARNING:
-                unreal.log_warning(f"[PyJalLib] {record.getMessage()}")
+                unreal.log_warning(f"[PyJalLib] {message}")
             elif record.levelno >= logging.INFO:
-                unreal.log(f"[PyJalLib] {record.getMessage()}")
+                unreal.log(f"[PyJalLib] {message}")
             else:  # DEBUG
-                unreal.log(f"[PyJalLib-DEBUG] {record.getMessage()}")
+                unreal.log(f"[PyJalLib-DEBUG] {message}")
                 
         except ImportError:
             # unreal 모듈이 없는 경우 표준 출력 사용
-            print(f"[PyJalLib] {record.getMessage()}")
+            message = self.format(record) if self.formatter else record.getMessage()
+            print(f"[PyJalLib] {message}")
         except Exception:
             # 모든 예외를 무시하여 로깅 실패가 애플리케이션을 중단하지 않도록 함
             pass
 
-def _setup_ue5_logging():
-    """UE5 모듈의 중앙 집중식 로깅 설정"""
-    
-    # Documents 폴더 경로 가져오기
-    documents_path = Path.home() / "Documents"
-    log_folder = documents_path / "PyJalLib" / "logs"
-    
-    # 로그 폴더 생성
-    log_folder.mkdir(parents=True, exist_ok=True)
-    
-    # 로그 파일명 생성 (날짜 포함)
-    current_date = datetime.now().strftime("%Y%m%d")
-    log_filename = f"ue5_module_{current_date}.log"
-    log_file_path = log_folder / log_filename
-    
-    # UE5 모듈 전용 로거 생성
-    ue5_logger = logging.getLogger('pyjallib.ue5')
-    ue5_logger.setLevel(logging.DEBUG)
-    
-    # 기존 핸들러 제거 (중복 방지)
-    for handler in ue5_logger.handlers[:]:
-        ue5_logger.removeHandler(handler)
-    
-    # 파일 핸들러 설정 (UTF-8 인코딩)
-    file_handler = logging.FileHandler(log_file_path, encoding='utf-8')
-    file_handler.setLevel(logging.DEBUG)
-    
-    # UE5 전용 핸들러 설정
-    ue5_handler = UE5LogHandler()
-    ue5_handler.setLevel(logging.INFO)  # UE5에서는 INFO 이상만 표시
-    
-    # 포맷터 설정
-    formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
-    
-    file_handler.setFormatter(formatter)
-    ue5_handler.setFormatter(formatter)
-    
-    # 핸들러 추가
-    ue5_logger.addHandler(file_handler)
-    ue5_logger.addHandler(ue5_handler)
-    
-    # 로거가 상위 로거로 전파되지 않도록 설정
-    ue5_logger.propagate = False
+
+class UE5Logger(Logger):
+    """UE5 전용 로거 클래스 - 메인 Logger 클래스를 상속하여 UE5 기능을 추가"""
+    
+    def __init__(self, inLogPath: Optional[str] = None, inLogFileName: Optional[str] = None, 
+                 inEnableConsole: bool = True, inEnableUE5: bool = True):
+        """UE5 로거 인스턴스 초기화
+        
+        Args:
+            inLogPath (str, optional): 로그 파일 저장 경로. 
+                                     None인 경우 기본 경로 사용 (Documents/PyJalLib/logs)
+            inLogFileName (str, optional): 로그 파일명 (확장자 제외). 
+                                         None인 경우 기본값 "ue5_module" 사용
+                                         실제 파일명은 "YYYYMMDD_파일명.log" 형식으로 생성
+            inEnableConsole (bool): 콘솔 출력 활성화 여부 (기본값: True)
+            inEnableUE5 (bool): UE5 출력 활성화 여부 (기본값: True)
+        """
+        # UE5 기본 파일명 설정
+        if inLogFileName is None:
+            inLogFileName = "ue5_module"
+            
+        # 부모 클래스 초기화
+        super().__init__(inLogPath, inLogFileName, inEnableConsole)
+        
+        # UE5 핸들러 설정
+        self._enableUE5 = inEnableUE5
+        if self._enableUE5:
+            self._add_ue5_handler()
+    
+    def set_ue5_log_level(self, inLevel: str):
+        """
+        UE5 출력의 로깅 레벨을 설정합니다.
+        
+        Args:
+            inLevel (str): 로깅 레벨 ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
+        """
+        level_map = {
+            'DEBUG': logging.DEBUG,
+            'INFO': logging.INFO,
+            'WARNING': logging.WARNING,
+            'ERROR': logging.ERROR,
+            'CRITICAL': logging.CRITICAL
+        }
+        
+        if inLevel.upper() not in level_map:
+            self.warning(f"잘못된 로깅 레벨: {inLevel}. 기본값 INFO로 설정합니다.")
+            inLevel = 'INFO'
+        
+        # UE5 핸들러 찾기
+        for handler in self._logger.handlers:
+            if isinstance(handler, UE5LogHandler):
+                handler.setLevel(level_map[inLevel.upper()])
+                self.info(f"UE5 로깅 레벨이 {inLevel.upper()}로 설정되었습니다.")
+                return
+        
+        self.warning("UE5 핸들러를 찾을 수 없습니다.")
+    
+    def enable_ue5_output(self, inEnable: bool = True):
+        """
+        UE5 출력을 활성화/비활성화합니다.
+        
+        Args:
+            inEnable (bool): UE5 출력 활성화 여부
+        """
+        if inEnable and not self._enableUE5:
+            # UE5 핸들러 추가
+            self._add_ue5_handler()
+            self._enableUE5 = True
+            self.info("UE5 출력이 활성화되었습니다.")
+        elif not inEnable and self._enableUE5:
+            # UE5 핸들러 제거
+            self._remove_ue5_handler()
+            self._enableUE5 = False
+            self.info("UE5 출력이 비활성화되었습니다.")
+    
+    def _add_ue5_handler(self):
+        """UE5 핸들러를 로거에 추가"""
+        try:
+            ue5_handler = UE5LogHandler()
+            ue5_handler.setLevel(logging.INFO)  # UE5에서는 INFO 이상만 표시
+            ue5_handler.setFormatter(self._get_formatter())
+            self._logger.addHandler(ue5_handler)
+        except Exception:
+            # UE5 핸들러 생성 실패 시 무시
+            pass
     
-    return ue5_logger
+    def _remove_ue5_handler(self):
+        """UE5 핸들러를 로거에서 제거"""
+        for handler in self._logger.handlers[:]:
+            if isinstance(handler, UE5LogHandler):
+                self._logger.removeHandler(handler)
+                try:
+                    handler.close()
+                except Exception:
+                    pass
+    
+    def _log_separator(self, inMessage: str) -> None:
+        """구분선 메시지를 모든 핸들러에 직접 출력 (UE5 핸들러 포함)"""
+        # 구분선은 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 isinstance(handler, UE5LogHandler):
+                        # UE5 핸들러의 경우 직접 emit 호출
+                        handler.emit(separator_record)
+                    elif hasattr(handler, 'stream'):
+                        # 구분선만 특별한 포맷으로 출력
+                        handler.stream.write(inMessage + "\n")
+                        if hasattr(handler, 'flush'):
+                            handler.flush()
+            except Exception:
+                # 핸들러 오류 시 무시
+                pass
+
 
-# 로깅 설정 실행
-ue5_logger = _setup_ue5_logging()
+# 편의를 위한 전역 UE5 로거 인스턴스
+ue5_logger = UE5Logger()
 
+# 호환성을 위한 기존 함수들
 def set_log_level(inLevel: str):
     """
     UE5 모듈의 로깅 레벨을 설정합니다.
@@ -108,7 +194,7 @@ def set_log_level(inLevel: str):
         ue5_logger.warning(f"잘못된 로깅 레벨: {inLevel}. 기본값 INFO로 설정합니다.")
         inLevel = 'INFO'
     
-    ue5_logger.setLevel(level_map[inLevel.upper()])
+    ue5_logger._logger.setLevel(level_map[inLevel.upper()])
     ue5_logger.info(f"로깅 레벨이 {inLevel.upper()}로 설정되었습니다.")
 
 def set_ue5_log_level(inLevel: str):
@@ -118,26 +204,7 @@ def set_ue5_log_level(inLevel: str):
     Args:
         inLevel (str): 로깅 레벨 ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
     """
-    level_map = {
-        'DEBUG': logging.DEBUG,
-        'INFO': logging.INFO,
-        'WARNING': logging.WARNING,
-        'ERROR': logging.ERROR,
-        'CRITICAL': logging.CRITICAL
-    }
-    
-    if inLevel.upper() not in level_map:
-        ue5_logger.warning(f"잘못된 로깅 레벨: {inLevel}. 기본값 INFO로 설정합니다.")
-        inLevel = 'INFO'
-    
-    # UE5 핸들러 찾기
-    for handler in ue5_logger.handlers:
-        if isinstance(handler, UE5LogHandler):
-            handler.setLevel(level_map[inLevel.upper()])
-            ue5_logger.info(f"UE5 로깅 레벨이 {inLevel.upper()}로 설정되었습니다.")
-            return
-    
-    ue5_logger.warning("UE5 핸들러를 찾을 수 없습니다.")
+    ue5_logger.set_ue5_log_level(inLevel)
 
 def get_log_file_path():
     """
@@ -149,7 +216,7 @@ def get_log_file_path():
     documents_path = Path.home() / "Documents"
     log_folder = documents_path / "PyJalLib" / "logs"
     current_date = datetime.now().strftime("%Y%m%d")
-    log_filename = f"ue5_module_{current_date}.log"
+    log_filename = f"{current_date}_ue5_module.log"
     return str(log_folder / log_filename)
 
 def set_log_file_path(inLogFolder: str = None, inLogFilename: str = None):
@@ -160,41 +227,15 @@ def set_log_file_path(inLogFolder: str = None, inLogFilename: str = None):
         inLogFolder (str, optional): 로그 폴더 경로. None인 경우 기본 Documents/PyJalLib/logs 사용
         inLogFilename (str, optional): 로그 파일명. None인 경우 기본 날짜 기반 파일명 사용
     """
-    # 기본값 설정
-    if inLogFolder is None:
-        documents_path = Path.home() / "Documents"
-        inLogFolder = str(documents_path / "PyJalLib" / "logs")
-    
-    if inLogFilename is None:
-        current_date = datetime.now().strftime("%Y%m%d")
-        inLogFilename = f"ue5_module_{current_date}.log"
-    
-    # 경로 생성
-    log_folder = Path(inLogFolder)
-    log_folder.mkdir(parents=True, exist_ok=True)
-    log_file_path = log_folder / inLogFilename
-    
-    # 기존 파일 핸들러 제거
-    for handler in ue5_logger.handlers[:]:
-        if isinstance(handler, logging.FileHandler):
-            ue5_logger.removeHandler(handler)
-            handler.close()
-    
-    # 새로운 파일 핸들러 생성
-    new_file_handler = logging.FileHandler(log_file_path, encoding='utf-8')
-    new_file_handler.setLevel(logging.DEBUG)
-    
-    # 포맷터 설정 (기존과 동일)
-    formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
-    new_file_handler.setFormatter(formatter)
+    # 새로운 UE5Logger 인스턴스 생성
+    global ue5_logger
     
-    # 새 핸들러 추가
-    ue5_logger.addHandler(new_file_handler)
+    # 기존 로거 정리
+    ue5_logger.close()
     
-    ue5_logger.info(f"로그 파일 경로가 변경되었습니다: {log_file_path}")
+    # 새로운 로거 생성
+    ue5_logger = UE5Logger(inLogPath=inLogFolder, inLogFileName=inLogFilename)
+    ue5_logger.info(f"로그 파일 경로가 변경되었습니다.")
 
 # 로깅 설정 완료 메시지
 ue5_logger.info("UE5 모듈 로깅 시스템 초기화 완료") 

pyjallib/ue5/templateProcessor.py

@@ -13,7 +13,8 @@ from .templates import (
     get_available_templates,
     ANIM_IMPORT_TEMPLATE,
     SKELETON_IMPORT_TEMPLATE,
-    SKELETAL_MESH_IMPORT_TEMPLATE
+    SKELETAL_MESH_IMPORT_TEMPLATE,
+    BATCH_ANIM_IMPORT_TEMPLATE
 )
 
 
@@ -197,7 +198,39 @@ class TemplateProcessor:
             inOutputPath = self.get_default_output_path(SKELETAL_MESH_IMPORT_TEMPLATE, "skeletalMeshImportScript")
         
         return self.process_template(template_path, inOutputPath, inTemplateData)
-
+    
+    def process_batch_anim_import_template(self, 
+                                        inTemplateData: Dict[str, Any], 
+                                        inOutputPath: Optional[str] = None) -> str:
+        """
+        배치 애니메이션 임포트 전용 템플릿 처리
+        
+        Args:
+            inTemplateData (Dict[str, Any]): 템플릿 데이터
+                필수 키:
+                - inExtPackagePath: 외부 패키지 경로
+                - inAnimFbxPaths: 애니메이션 FBX 경로들 (리스트)
+                - inSkeletonFbxPaths: 스켈레톤 FBX 경로들 (리스트)
+                - inContentRootPrefix: Content 루트 경로
+                - inFbxRootPrefix: FBX 루트 경로
+            inOutputPath (Optional[str]): 출력 파일 경로. None인 경우 기본 경로 사용
+            
+        Returns:
+            str: 처리된 템플릿 내용
+        """
+        # 필수 키 검증
+        required_keys = ['inExtPackagePath', 'inAnimFbxPaths', 'inSkeletonFbxPaths', 
+                        'inContentRootPrefix', 'inFbxRootPrefix']
+        if not self.validate_template_data(BATCH_ANIM_IMPORT_TEMPLATE, inTemplateData, required_keys):
+            raise ValueError(f"배치 애니메이션 템플릿에 필요한 키가 누락되었습니다: {required_keys}")
+        
+        template_path = get_template_path(BATCH_ANIM_IMPORT_TEMPLATE)
+        
+        if inOutputPath is None:
+            inOutputPath = self.get_default_output_path(BATCH_ANIM_IMPORT_TEMPLATE, "batchAnimImportScript")
+        
+        return self.process_template(template_path, inOutputPath, inTemplateData)
+    
     # === 유틸리티 메서드 ===
     def validate_template_data(self, template_type: str, template_data: Dict[str, Any], required_keys: list = None) -> bool:
         """

pyjallib/ue5/templates/__init__.py

@@ -14,12 +14,14 @@ from typing import Dict, Optional
 ANIM_IMPORT_TEMPLATE = "animImport"
 SKELETON_IMPORT_TEMPLATE = "skeletonImport" 
 SKELETAL_MESH_IMPORT_TEMPLATE = "skeletalMeshImport"
+BATCH_ANIM_IMPORT_TEMPLATE = "batchAnimImport"
 
 # 템플릿 파일 매핑
 _TEMPLATE_FILE_MAP = {
     ANIM_IMPORT_TEMPLATE: "animImportTemplate.py",
     SKELETON_IMPORT_TEMPLATE: "skeletonImportTemplate.py",
-    SKELETAL_MESH_IMPORT_TEMPLATE: "skeletalMeshImportTemplate.py"
+    SKELETAL_MESH_IMPORT_TEMPLATE: "skeletalMeshImportTemplate.py",
+    BATCH_ANIM_IMPORT_TEMPLATE: "batchAnimImportTemplate.py"
 }
 
 def get_template_path(template_name: str) -> str:
@@ -27,7 +29,7 @@ def get_template_path(template_name: str) -> str:
     템플릿 이름으로 템플릿 파일 경로 반환
     
     Args:
-        template_name (str): 'animImport', 'skeletonImport', 'skeletalMeshImport' 중 하나
+        template_name (str): 'animImport', 'skeletonImport', 'skeletalMeshImport', 'batchAnimImport' 중 하나
     
     Returns:
         str: 템플릿 파일의 절대 경로
@@ -102,5 +104,6 @@ __all__ = [
     'validate_template_name',
     'ANIM_IMPORT_TEMPLATE',
     'SKELETON_IMPORT_TEMPLATE',
-    'SKELETAL_MESH_IMPORT_TEMPLATE'
+    'SKELETAL_MESH_IMPORT_TEMPLATE',
+    'BATCH_ANIM_IMPORT_TEMPLATE'
 ] 

pyjallib/ue5/templates/batchAnimImportTemplate.py

@@ -0,0 +1,21 @@
+import sys
+import os
+from pathlib import Path
+
+# 프로젝트 루트 디렉토리 추가 (PyJalLib 디렉토리)
+extPackagePath = r'{inExtPackagePath}'
+
+if extPackagePath not in sys.path:
+    sys.path.insert(0, extPackagePath)
+
+from pyjallib.ue5.inUnreal.animationImporter import AnimationImporter
+
+fbxPaths = {inAnimFbxPaths}
+skeletonPaths = {inSkeletonFbxPaths}
+
+contentRootPrefix = r'{inContentRootPrefix}'
+fbxRootPrefix = r'{inFbxRootPrefix}'
+
+animImporter = AnimationImporter(inContentRootPrefix=contentRootPrefix, inFbxRootPrefix=fbxRootPrefix)
+
+result = animImporter.import_animations(fbxPaths, skeletonPaths)

{pyjallib-0.1.17.dist-info → pyjallib-0.1.19.dist-info}/METADATA

@@ -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