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

pyjallib/ue5/__init__.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Unreal Engine 5 패키지
+Unreal Engine 5 작업을 위한 모듈 모음
+
+새로운 구조:
+- Unreal Engine이 실행되지 않아도 사용 가능한 기능들 (templates, templateProcessor, logger 등)
+- Unreal Engine이 필요한 기능들은 inUnreal 서브모듈에 위치
+"""
+
+# Unreal Engine 없이도 사용 가능한 기본 모듈들
+__all__ = []
+
+# Logger (조건부 unreal 지원)
+try:
+    from .logger import (
+        ue5_logger,
+        set_log_level,
+        set_ue5_log_level,
+        get_log_file_path,
+        set_log_file_path
+    )
+    __all__.extend([
+        'ue5_logger',
+        'set_log_level',
+        'set_ue5_log_level',
+        'get_log_file_path',
+        'set_log_file_path'
+    ])
+except ImportError as e:
+    ue5_logger = None
+    set_log_level = None
+    set_ue5_log_level = None
+    get_log_file_path = None
+    set_log_file_path = None
+    print(f"[PyJalLib] UE5 Logger를 로드할 수 없습니다: {e}")
+
+# TemplateProcessor (Unreal 없이 사용 가능)
+try:
+    from .templateProcessor import TemplateProcessor
+    __all__.append('TemplateProcessor')
+except ImportError as e:
+    TemplateProcessor = None
+    if ue5_logger:
+        ue5_logger.error(f"TemplateProcessor를 로드할 수 없습니다: {e}")
+    else:
+        print(f"[PyJalLib] TemplateProcessor를 로드할 수 없습니다: {e}")
+
+# Templates 모듈 (Unreal 없이 사용 가능)
+try:
+    from .templates import (
+        get_template_path,
+        get_all_template_paths,
+        get_available_templates,
+        validate_template_name,
+        ANIM_IMPORT_TEMPLATE,
+        SKELETON_IMPORT_TEMPLATE,
+        SKELETAL_MESH_IMPORT_TEMPLATE
+    )
+    __all__.extend([
+        'get_template_path',
+        'get_all_template_paths',
+        'get_available_templates',
+        'validate_template_name',
+        'ANIM_IMPORT_TEMPLATE',
+        'SKELETON_IMPORT_TEMPLATE',
+        'SKELETAL_MESH_IMPORT_TEMPLATE'
+    ])
+except ImportError as e:
+    get_template_path = None
+    get_all_template_paths = None
+    get_available_templates = None
+    validate_template_name = None
+    ANIM_IMPORT_TEMPLATE = None
+    SKELETON_IMPORT_TEMPLATE = None
+    SKELETAL_MESH_IMPORT_TEMPLATE = None
+    if ue5_logger:
+        ue5_logger.error(f"Templates 모듈을 로드할 수 없습니다: {e}")
+    else:
+        print(f"[PyJalLib] Templates 모듈을 로드할 수 없습니다: {e}")
+
+# disableInterchangeFrameWork (Unreal 없이 사용 가능)
+try:
+    from .disableInterchangeFrameWork import add_disabled_plugins_to_uproject
+    __all__.append('add_disabled_plugins_to_uproject')
+except ImportError as e:
+    add_disabled_plugins_to_uproject = None
+    if ue5_logger:
+        ue5_logger.error(f"disableInterchangeFrameWork를 로드할 수 없습니다: {e}")
+    else:
+        print(f"[PyJalLib] disableInterchangeFrameWork를 로드할 수 없습니다: {e}")
+
+# UE5 의존성 상태를 확인할 수 있는 함수
+def is_ue5_available() -> bool:
+    """
+    Unreal Engine 5가 사용 가능한지 확인합니다.
+    
+    Returns:
+        bool: UE5가 사용 가능하면 True, 그렇지 않으면 False
+    """
+    try:
+        import unreal
+        return True
+    except ImportError:
+        return False
+
+def get_available_modules() -> dict:
+    """
+    현재 사용 가능한 모듈 목록을 반환합니다.
+    
+    Returns:
+        dict: 모듈 카테고리별 사용 가능한 모듈 정보
+    """
+    available = {
+        'core': [],
+        'templates': [],
+        'utils': [],
+        'unreal_dependent': []
+    }
+    
+    # Core 모듈들
+    if ue5_logger is not None:
+        available['core'].append('logger')
+    if TemplateProcessor is not None:
+        available['core'].append('TemplateProcessor')
+    
+    # Templates 관련
+    if get_template_path is not None:
+        available['templates'].append('template_management')
+    
+    # Utilities
+    if add_disabled_plugins_to_uproject is not None:
+        available['utils'].append('disableInterchangeFrameWork')
+    
+    # Unreal 의존성 모듈들 (inUnreal 서브모듈에서 가져오기)
+    try:
+        from . import inUnreal
+        if hasattr(inUnreal, 'get_available_modules'):
+            available['unreal_dependent'] = inUnreal.get_available_modules()
+    except ImportError:
+        available['unreal_dependent'] = []
+    
+    return available
+
+def get_module_status() -> dict:
+    """
+    모듈 상태 정보를 반환합니다.
+    
+    Returns:
+        dict: 모듈 상태 정보
+    """
+    status = {
+        'ue5_available': is_ue5_available(),
+        'available_modules': get_available_modules(),
+        'structure': {
+            'core_modules': 'Unreal Engine 없이 사용 가능',
+            'inUnreal_modules': 'Unreal Engine 필요',
+            'templates': '템플릿 파일 관리'
+        }
+    }
+    return status
+
+# 헬퍼 함수들도 __all__에 추가
+__all__.extend([
+    'is_ue5_available', 
+    'get_available_modules', 
+    'get_module_status'
+])

pyjallib/ue5/disableInterchangeFrameWork.py

@@ -0,0 +1,82 @@
+import json
+from pathlib import Path
+from .logger import ue5_logger
+
+def add_disabled_plugins_to_uproject(uproject_path):
+    """
+    특정 플러그인들을 Enabled=false 상태로 추가하여 temp_ 접두사가 붙은 새 파일로 저장
+    
+    Args:
+        uproject_path (str): 원본 .uproject 파일 경로
+    """
+    
+    # 비활성화 상태로 추가할 플러그인들
+    plugins_to_add = [
+        {
+            "Name": "MeshPainting",
+            "Enabled": False
+        },
+        {
+            "Name": "InterchangeEditor",
+            "Enabled": False,
+            "SupportedTargetPlatforms": [
+                "Win64",
+                "Linux",
+                "Mac"
+            ]
+        },
+        {
+            "Name": "GLTFExporter",
+            "Enabled": False
+        },
+        {
+            "Name": "InterchangeTests",
+            "Enabled": False
+        },
+        {
+            "Name": "Interchange",
+            "Enabled": False,
+            "SupportedTargetPlatforms": [
+                "Win64",
+                "Linux",
+                "Mac"
+            ]
+        },
+        {
+            "Name": "InterchangeAssets",
+            "Enabled": False
+        }
+    ]
+    
+    # 파일 읽기
+    with open(uproject_path, 'r', encoding='utf-8') as f:
+        project_data = json.load(f)
+    
+    # 기존 플러그인 이름들 확인
+    existing_plugin_names = set()
+    if 'Plugins' in project_data:
+        existing_plugin_names = {plugin['Name'] for plugin in project_data['Plugins']}
+    
+    # 새 플러그인 추가 (중복 체크)
+    added_count = 0
+    for plugin in plugins_to_add:
+        if plugin['Name'] not in existing_plugin_names:
+            project_data['Plugins'].append(plugin)
+            added_count += 1
+            ue5_logger.info(f"추가됨 (비활성화): {plugin['Name']}")
+        else:
+            ue5_logger.info(f"이미 존재: {plugin['Name']}")
+    
+    # 출력 파일 경로 생성 (temp_ 접두사 추가)
+    input_path = Path(uproject_path)
+    output_filename = f"temp_{input_path.name}"
+    output_path = input_path.parent / output_filename
+    
+    # 파일 저장
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(project_data, f, indent='\t', ensure_ascii=False)
+    
+    ue5_logger.info(f"총 {added_count}개 플러그인 추가 (비활성화 상태)")
+    ue5_logger.info(f"출력 파일: {output_path}")
+    
+    return output_path

pyjallib/ue5/inUnreal/__init__.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 inUnreal 패키지
+Unreal Engine 5가 실행 중일 때만 사용 가능한 모듈들
+
+주의: 이 패키지의 모든 모듈은 Unreal Engine이 실행 중일 때만 임포트 가능합니다.
+"""
+
+# UE5 가용성 확인
+def is_ue5_available() -> bool:
+    """
+    Unreal Engine 5가 사용 가능한지 확인합니다.
+    
+    Returns:
+        bool: UE5가 사용 가능하면 True, 그렇지 않으면 False
+    """
+    try:
+        import unreal
+        return True
+    except ImportError:
+        return False
+
+# 기본적으로 사용 가능한 모듈들
+__all__ = ['is_ue5_available']
+
+# UE5가 사용 가능한 경우에만 모듈들을 임포트
+if is_ue5_available():
+    try:
+        from .importerSettings import ImporterSettings
+        __all__.append('ImporterSettings')
+    except ImportError as e:
+        ImporterSettings = None
+        print(f"[PyJalLib] ImporterSettings 임포트 실패: {e}")
+
+    try:
+        from .baseImporter import BaseImporter
+        __all__.append('BaseImporter')
+    except ImportError as e:
+        BaseImporter = None
+        print(f"[PyJalLib] BaseImporter 임포트 실패: {e}")
+
+    try:
+        from .skeletonImporter import SkeletonImporter
+        __all__.append('SkeletonImporter')
+    except ImportError as e:
+        SkeletonImporter = None
+        print(f"[PyJalLib] SkeletonImporter 임포트 실패: {e}")
+
+    try:
+        from .skeletalMeshImporter import SkeletalMeshImporter
+        __all__.append('SkeletalMeshImporter')
+    except ImportError as e:
+        SkeletalMeshImporter = None
+        print(f"[PyJalLib] SkeletalMeshImporter 임포트 실패: {e}")
+
+    try:
+        from .animationImporter import AnimationImporter
+        __all__.append('AnimationImporter')
+    except ImportError as e:
+        AnimationImporter = None
+        print(f"[PyJalLib] AnimationImporter 임포트 실패: {e}")
+
+else:
+    # UE5가 사용 불가능한 경우 모든 모듈을 None으로 설정
+    ImporterSettings = None
+    BaseImporter = None
+    SkeletonImporter = None
+    SkeletalMeshImporter = None
+    AnimationImporter = None
+    print("[PyJalLib] Unreal Engine이 실행되지 않았습니다. inUnreal 모듈들을 사용할 수 없습니다.")
+
+def get_available_modules() -> list:
+    """
+    현재 사용 가능한 모듈 목록을 반환합니다.
+    
+    Returns:
+        list: 사용 가능한 모듈 이름 목록
+    """
+    available = []
+    if 'ImporterSettings' in __all__ and ImporterSettings is not None:
+        available.append('ImporterSettings')
+    if 'BaseImporter' in __all__ and BaseImporter is not None:
+        available.append('BaseImporter')
+    if 'SkeletonImporter' in __all__ and SkeletonImporter is not None:
+        available.append('SkeletonImporter')
+    if 'SkeletalMeshImporter' in __all__ and SkeletalMeshImporter is not None:
+        available.append('SkeletalMeshImporter')
+    if 'AnimationImporter' in __all__ and AnimationImporter is not None:
+        available.append('AnimationImporter')
+    return available
+
+# 헬퍼 함수도 __all__에 추가
+__all__.append('get_available_modules') 

pyjallib/ue5/inUnreal/animationImporter.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 애니메이션 임포터 모듈
+
+이 모듈은 FBX 파일에서 애니메이션 에셋을 UE5로 임포트하는 기능을 제공합니다.
+PyJalLib의 naming 모듈을 사용하여 에셋 이름을 자동 생성합니다.
+"""
+
+import unreal
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# UE5 모듈 import
+from .baseImporter import BaseImporter
+from ..logger import ue5_logger
+from .importerSettings import ImporterSettings
+
+class AnimationImporter(BaseImporter):
+    def __init__(self, inContentRootPrefix: str, inFbxRootPrefix: str):
+        super().__init__(inContentRootPrefix, inFbxRootPrefix, "Animation")
+        ue5_logger.info("AnimationImporter 초기화 완료")
+    
+    @property
+    def asset_type(self) -> str:
+        return "Animation"
+    
+    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}")
+        
+        importOptions = self.importerSettings.load_options()
+        ue5_logger.debug("애니메이션 임포트 옵션 로드 완료")
+        
+        # 스켈레톤 필수 설정
+        if inFbxSkeletonPath is None:
+            error_msg = "애니메이션 임포트에는 스켈레톤이 필수입니다"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        skeletonPath = self.convert_fbx_path_to_skeleton_path(inFbxSkeletonPath)
+        skeletonAssetData = unreal.EditorAssetLibrary.find_asset_data(skeletonPath)
+        if not skeletonAssetData.is_valid():
+            error_msg = f"스켈레톤 에셋을 찾을 수 없음: {skeletonPath}"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        animSkeleton = skeletonAssetData.get_asset()
+        importOptions.set_editor_property('skeleton', animSkeleton)
+        ue5_logger.debug(f"스켈레톤 설정됨: {animSkeleton.get_name()}")
+        
+        # 에셋 이름 결정: FBX 파일 이름에서 확장자 제거
+        assetName = Path(inFbxFile).stem
+        
+        task = unreal.AssetImportTask()
+        task.automated = True
+        task.destination_path = inDestinationPath
+        task.filename = inFbxFile
+        task.destination_name = assetName
+        task.replace_existing = True
+        task.save = True
+        task.options = importOptions
+        
+        ue5_logger.debug(f"애니메이션 임포트 태스크 생성 완료: Destination={inDestinationPath}, AssetName={assetName}")
+        return task
+    
+    def import_animation(self, inFbxFile: str, inFbxSkeletonPath: str, inAssetName: str = None, inDescription: str = None):
+        ue5_logger.info(f"애니메이션 임포트 시작: {inFbxFile}")
+        
+        destinationPath, assetName = self._prepare_import_paths(inFbxFile, inAssetName)
+        assetFullPath = f"{destinationPath}/{assetName}"
+        
+        # 기존 에셋이 있는 경우 소스 컨트롤에서 체크아웃
+        if unreal.Paths.file_exists(assetFullPath):
+            unreal.SourceControl.check_out_or_add_file(assetFullPath, silent=True)
+        
+        task = self.create_import_task(inFbxFile, destinationPath, inFbxSkeletonPath)
+        
+        ue5_logger.info(f"애니메이션 임포트 실행: {inFbxFile} -> {destinationPath}/{assetName}")
+        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
+        
+        result = task.get_objects()
+        if len(result) == 0:
+            error_msg = f"애니메이션 임포트 실패: {inFbxFile}"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        importedObjectPaths = task.imported_object_paths
+        refObjectPaths = self.get_dirty_deps(assetFullPath)
+        
+        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
+        
+        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}")