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

pyjallib/ue5/inUnreal/importerSettings.py

@@ -0,0 +1,179 @@
+"""
+UE5 에셋 임포트 설정 관리 모듈
+
+이 모듈은 UE5 에셋 임포트에 필요한 설정을 관리합니다.
+JSON 설정 파일을 로드하고, 프리셋 기반으로 설정을 반환하는 기능을 제공합니다.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+import unreal
+from ..logger import ue5_logger
+
+
+class ImporterSettings:
+    """UE5 에셋 임포트 설정 관리 클래스"""
+    
+    def __init__(self, inContentRootPrefix: str, inFbxRootPrefix: str, inPresetName: str):
+        """
+        ImporterSettings 초기화
+        
+        Args:
+            inContentRootPrefix: UE5 Content 경로의 루트 접두사
+            inFbxRootPrefix: FBX 파일 경로의 루트 접두사
+            inPresetName: 사용할 프리셋 이름 (Skeleton, SkeletalMesh, Animation 중 하나)
+        """
+        self.contentRootPrefix = inContentRootPrefix
+        self.fbxRootPrefix = inFbxRootPrefix
+        self.presetName = inPresetName
+        
+        self.configPath = Path(__file__).parent / 'ConfigFiles' / 'UE5ImportConfig.json'
+        ue5_logger.debug(f"ImporterSettings 초기화: ContentRoot={inContentRootPrefix}, FbxRoot={inFbxRootPrefix}, Preset={inPresetName}")
+    
+    def load_preset(self, inPresetName: Optional[str] = None):
+        if inPresetName is None:
+            inPresetName = self.presetName
+            
+        if inPresetName is None:
+            raise ValueError("Preset name is required")
+        
+        preset_path = Path(__file__).parent / 'ConfigFiles' / f'{inPresetName}.json'
+    
+    def set_options_for_skeleton_import(self):
+        """
+        스켈레톤 임포트를 위한 옵션을 설정합니다.
+        
+        스켈레탈 메쉬는 임포트하고, 애니메이션은 임포트하지 않으며,
+        매테리얼이나 텍스처도 임포트하지 않고, 스켈레톤은 새로 생성합니다.
+        
+        Returns:
+            unreal.FbxImportUI: 설정된 임포트 옵션
+        """
+        # FBX 임포트 옵션 설정
+        fbxImportOptions = unreal.FbxImportUI()
+        fbxImportOptions.reset_to_default()
+        fbxImportOptions.set_editor_property('original_import_type', unreal.FBXImportType.FBXIT_SKELETAL_MESH)  # 스켈레탈 메쉬 타입
+        
+        # 메시 임포트 옵션 설정
+        fbxImportOptions.set_editor_property('import_mesh', True)  # 스켈레탈 메쉬 임포트
+        fbxImportOptions.set_editor_property('import_textures', False)  # 텍스처 임포트 안함
+        fbxImportOptions.set_editor_property('import_materials', False)  # 매테리얼 임포트 안함
+        fbxImportOptions.set_editor_property('import_animations', False)  # 애니메이션 임포트 안함
+        fbxImportOptions.set_editor_property('import_as_skeletal', True)  # 스켈레탈 메쉬로 임포트
+        fbxImportOptions.set_editor_property('mesh_type_to_import', unreal.FBXImportType.FBXIT_SKELETAL_MESH)  # 스켈레탈 메쉬로 임포트
+        fbxImportOptions.set_editor_property('create_physics_asset', False)  # 피직 애셋 생성 안함
+        
+        # 스켈레탈 메쉬 임포트 세부 옵션
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('import_morph_targets', False)  # 모프 타겟 임포트 안함
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('import_mesh_lo_ds', False)  # LOD 임포트 안함
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('convert_scene_unit', False)  # 씬 단위 변환 안함
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('force_front_x_axis', False)  # X축 강제 변환 안함
+        
+        # LOD 임포트 (필요하다면)
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('import_mesh_lo_ds', False)  # LOD를 임포트하지 않음
+        
+        # 스켈레톤 생성 옵션
+        fbxImportOptions.set_editor_property('skeleton', None)  # 새 스켈레톤 생성
+        
+        return fbxImportOptions
+
+    def set_options_for_skeletal_mesh_import(self):
+        """
+        스켈레탈 메쉬 임포트를 위한 옵션을 설정합니다.
+        
+        애니메이션은 임포트하지 않고, 메쉬만 임포트하며, 텍스처와 매테리얼은 임포트하지 않고,
+        피직 애셋은 만들지 않고, 스켈레톤은 생성하지 않으며, 모프 타겟은 임포트하고,
+        노멀과 탄젠트를 계산하여 Geometry and Skin weights로 임포트합니다.
+        
+        Returns:
+            unreal.FbxImportUI: 설정된 임포트 옵션
+        """
+        # FBX 임포트 옵션 설정
+        fbxImportOptions = unreal.FbxImportUI()
+        fbxImportOptions.reset_to_default()
+        fbxImportOptions.set_editor_property('original_import_type', unreal.FBXImportType.FBXIT_SKELETAL_MESH)  # 스켈레탈 메쉬 타입
+        
+        # 메시 임포트 옵션 설정
+        fbxImportOptions.set_editor_property('import_mesh', True)  # 메쉬 임포트
+        fbxImportOptions.set_editor_property('import_textures', False)  # 텍스처 임포트 안함
+        fbxImportOptions.set_editor_property('import_materials', False)  # 매테리얼 임포트 안함
+        fbxImportOptions.set_editor_property('import_animations', False)  # 애니메이션 임포트 안함
+        fbxImportOptions.set_editor_property('import_as_skeletal', True)  # 스켈레탈 메쉬로 임포트
+        fbxImportOptions.set_editor_property('create_physics_asset', False)  # 피직 애셋 생성 안함
+        
+        # 스켈레탈 메쉬 임포트 세부 옵션
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('import_morph_targets', True)  # 모프 타겟 임포트
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('normal_import_method', unreal.FBXNormalImportMethod.FBXNIM_IMPORT_NORMALS)  # 노멀 임포트
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('normal_generation_method', unreal.FBXNormalGenerationMethod.MIKK_T_SPACE)  # 탄젠트 계산
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('preserve_smoothing_groups', True)  # 스무딩 그룹 보존
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('reorder_material_to_fbx_order', True)  # Material 순서 재정렬
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('import_mesh_lo_ds', False)  # LOD 임포트 안함
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('convert_scene_unit', False)  # 씬 단위 변환 안함
+        fbxImportOptions.skeletal_mesh_import_data.set_editor_property('force_front_x_axis', False)  # X축 강제 변환 안함
+        
+        return fbxImportOptions
+    
+    def set_options_for_animation_import(self):
+        """
+        애니메이션 임포트를 위한 옵션을 설정합니다.
+        
+        애니메이션은 임포트하고, 메쉬는 임포트하지 않으며, 텍스처와 매테리얼은 임포트하지 않고,
+        피직 애셋은 만들지 않고, 스켈레톤은 생성하지 않으며, Animation Length는 Source와 같게 설정합니다.
+        
+        Returns:
+            unreal.FbxImportUI: 설정된 임포트 옵션
+        """
+        # FBX 임포트 옵션 설정
+        fbxImportOptions = unreal.FbxImportUI()
+        fbxImportOptions.reset_to_default()
+        fbxImportOptions.set_editor_property('original_import_type', unreal.FBXImportType.FBXIT_ANIMATION)  # 애니메이션 타입
+        
+        # 메시 임포트 옵션 설정
+        fbxImportOptions.set_editor_property('import_animations', True)  # 애니메이션 임포트
+        fbxImportOptions.set_editor_property('import_mesh', False)  # 메쉬 임포트 안함
+        fbxImportOptions.set_editor_property('import_textures', False)  # 텍스처 임포트 안함
+        fbxImportOptions.set_editor_property('import_materials', False)  # 매테리얼 임포트 안함
+        
+        fbxImportOptions.anim_sequence_import_data.set_editor_property('animation_length', unreal.FBXAnimationLengthImportType.FBXALIT_EXPORTED_TIME)
+        fbxImportOptions.anim_sequence_import_data.set_editor_property('do_not_import_curve_with_zero', True)
+        fbxImportOptions.anim_sequence_import_data.set_editor_property('import_bone_tracks', True)
+        fbxImportOptions.anim_sequence_import_data.set_editor_property('import_custom_attribute', True)
+        fbxImportOptions.anim_sequence_import_data.set_editor_property('import_meshes_in_bone_hierarchy', True)
+        
+        return fbxImportOptions
+
+    def load_options(self, inPresetName: Optional[str] = None) -> unreal.FbxImportUI:
+        """
+        PresetName에 따라 적절한 임포트 옵션을 로드합니다.
+        
+        Args:
+            inPresetName (Optional[str]): 프리셋 이름. None인 경우 self.presetName 사용
+        
+        Returns:
+            unreal.FbxImportUI: 설정된 임포트 옵션
+            
+        Raises:
+            ValueError: 지원하지 않는 프리셋 이름인 경우
+        """
+        if inPresetName is None:
+            inPresetName = self.presetName
+            
+        if inPresetName is None:
+            raise ValueError("Preset name is required")
+        
+        # PresetName에 따라 적절한 메소드 호출
+        if inPresetName.lower() == "skeleton":
+            return self.set_options_for_skeleton_import()
+        elif inPresetName.lower() == "skeletalmesh":
+            return self.set_options_for_skeletal_mesh_import()
+        elif inPresetName.lower() == "animation":
+            return self.set_options_for_animation_import()
+        else:
+            ue5_logger.error(f"Unsupported preset name: {inPresetName}. Supported presets: Skeleton, SkeletalMesh, Animation")
+            raise None
+
+
+    

pyjallib/ue5/inUnreal/skeletalMeshImporter.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 스켈레탈 메쉬 임포터 모듈
+UE5에서 스켈레탈 메쉬를 임포트하는 기능을 제공합니다.
+"""
+
+import unreal
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from ..logger import ue5_logger
+from .importerSettings import ImporterSettings
+
+# UE5 모듈 import
+from .baseImporter import BaseImporter
+
+class SkeletalMeshImporter(BaseImporter):
+    def __init__(self, inContentRootPrefix: str, inFbxRootPrefix: str):
+        super().__init__(inContentRootPrefix, inFbxRootPrefix, "SkeletalMesh")
+        ue5_logger.info("SkeletalMeshImporter 초기화 완료")
+    
+    @property
+    def asset_type(self) -> str:
+        return "SkeletalMesh"
+    
+    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)
+        
+        skeletalSkeleton = skeletonAssetData.get_asset()
+        importOptions.set_editor_property('skeleton', skeletalSkeleton)
+        ue5_logger.debug(f"스켈레톤 설정됨: {skeletalSkeleton.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_skeletal_mesh(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)
+        
+        # 임포트된 스켈레탈 메시 에셋의 시스템 경로 가져오기
+        importedSkeletalMesh = None
+        for asset in result:
+            if isinstance(asset, unreal.SkeletalMesh):
+                importedSkeletalMesh = asset
+                break
+        
+        if importedSkeletalMesh is None:
+            error_msg = f"스켈레탈 메시 에셋을 찾을 수 없음: {inFbxFile}"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        importedObjectPaths = self.get_dirty_deps(assetFullPath)
+        
+        skeletalMeshSystemFullPath = unreal.SystemLibrary.get_system_path(importedSkeletalMesh)
+        importedObjectPaths.append(skeletalMeshSystemFullPath)
+        
+        checkInDescription = f"SkeletalMesh Imported by {inFbxFile} to {assetFullPath}"
+        if inDescription is not None:
+            checkInDescription = inDescription
+        
+        unreal.SourceControl.check_in_files(importedObjectPaths, checkInDescription, silent=True)
+        
+        ue5_logger.info(f"스켈레탈 메시 임포트 성공: {inFbxFile} -> {len(result)}개 객체 생성")
+        return self._create_result_dict(inFbxFile, destinationPath, assetName, True) 

pyjallib/ue5/inUnreal/skeletonImporter.py

@@ -0,0 +1,105 @@
+#!/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 SkeletonImporter(BaseImporter):
+    def __init__(self, inContentRootPrefix: str, inFbxRootPrefix: str):
+        super().__init__(inContentRootPrefix, inFbxRootPrefix, "Skeleton")
+        ue5_logger.info("SkeletonImporter 초기화 완료")
+    
+    @property
+    def asset_type(self) -> str:
+        return "Skeleton"
+    
+    def _create_import_task(self, inFbxFile: str, inDestinationPath: str):
+        """스켈레톤 임포트를 위한 태스크 생성 - 새 스켈레톤 생성"""
+        ue5_logger.debug(f"스켈레톤 임포트 태스크 생성 시작: {inFbxFile}")
+        
+        importOptions = self.importerSettings.load_options()
+        ue5_logger.debug("스켈레톤 임포트 옵션 로드 완료")
+        
+        # 에셋 이름 결정: 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_skeleton(self, inFbxFile: str, inAssetName: str = None, inDescription: str = None):
+        ue5_logger.info(f"스켈레톤 임포트 시작: {inFbxFile}")
+        
+        destinationPath, assetName = self._prepare_import_paths(inFbxFile, inAssetName)
+        skeletonName = self.naming.replace_name_part("AssetType", assetName, self.naming.get_name_part("AssetType").get_value_by_description("Skeleton"))
+        
+        assetFullPath = f"{destinationPath}/{assetName}"
+        skeletonFullPath = f"{destinationPath}/{skeletonName}"
+        
+        if unreal.Paths.file_exists(assetFullPath) or unreal.Paths.file_exists(skeletonFullPath):
+            if unreal.Paths.file_exists(assetFullPath):
+                unreal.SourceControl.check_out_or_add_file(assetFullPath, silent=True)
+            if unreal.Paths.file_exists(skeletonFullPath):
+                unreal.SourceControl.check_out_or_add_file(skeletonFullPath, silent=True)
+        
+        task = self._create_import_task(inFbxFile, destinationPath)
+        
+        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)
+        
+        importedSkeletalMesh = None
+        for asset in result:
+            if isinstance(asset, unreal.SkeletalMesh):
+                importedSkeletalMesh = asset
+        importedSkeleton = importedSkeletalMesh.skeleton
+        skeletonRenameData = unreal.AssetRenameData(importedSkeleton, destinationPath, skeletonName)
+        unreal.AssetToolsHelpers.get_asset_tools().rename_assets([skeletonRenameData])
+        
+        skeletalMeshSystemFullPath = unreal.SystemLibrary.get_system_path(importedSkeletalMesh)
+        skeletonSystemFullPath = unreal.SystemLibrary.get_system_path(importedSkeletalMesh.skeleton)
+        
+        importedObjectPaths = self.get_dirty_deps(skeletonSystemFullPath)
+        importedObjectPaths.append(skeletonSystemFullPath)
+        
+        checkInDescription = f"Skeleton Imported by {inFbxFile} to {assetFullPath}"
+        if inDescription is not None:
+            checkInDescription = inDescription
+        
+        unreal.SourceControl.check_in_files(importedObjectPaths, checkInDescription, silent=True)
+        
+        ue5_logger.info(f"스켈레톤 임포트 성공: {inFbxFile} -> {len(result)}개 객체 생성")
+        return self._create_result_dict(inFbxFile, destinationPath, skeletonName, True)
+        
+        
+        
+        
+        
+        
+        

pyjallib/ue5/logger.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 모듈 로깅 설정 모듈
+UE5 모듈의 중앙 집중식 로깅 시스템을 관리합니다.
+"""
+
+import logging
+import os
+from pathlib import Path
+from datetime import datetime
+
+class UE5LogHandler(logging.Handler):
+    """UE5 전용 로그 핸들러 - UE5의 로그 시스템과 호환되도록 설계"""
+    
+    def emit(self, record):
+        """로그 레코드를 UE5 로그 시스템으로 전송"""
+        try:
+            # UE5의 unreal.log 함수 사용
+            import unreal
+            
+            # 로그 레벨에 따라 적절한 UE5 로그 함수 호출
+            if record.levelno >= logging.ERROR:
+                unreal.log_error(f"[PyJalLib] {record.getMessage()}")
+            elif record.levelno >= logging.WARNING:
+                unreal.log_warning(f"[PyJalLib] {record.getMessage()}")
+            elif record.levelno >= logging.INFO:
+                unreal.log(f"[PyJalLib] {record.getMessage()}")
+            else:  # DEBUG
+                unreal.log(f"[PyJalLib-DEBUG] {record.getMessage()}")
+                
+        except ImportError:
+            # unreal 모듈이 없는 경우 표준 출력 사용
+            print(f"[PyJalLib] {record.getMessage()}")
+        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
+    
+    return ue5_logger
+
+# 로깅 설정 실행
+ue5_logger = _setup_ue5_logging()
+
+def set_log_level(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:
+        ue5_logger.warning(f"잘못된 로깅 레벨: {inLevel}. 기본값 INFO로 설정합니다.")
+        inLevel = 'INFO'
+    
+    ue5_logger.setLevel(level_map[inLevel.upper()])
+    ue5_logger.info(f"로깅 레벨이 {inLevel.upper()}로 설정되었습니다.")
+
+def set_ue5_log_level(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:
+        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 핸들러를 찾을 수 없습니다.")
+
+def get_log_file_path():
+    """
+    현재 로그 파일의 경로를 반환합니다.
+    
+    Returns:
+        str: 로그 파일의 절대 경로
+    """
+    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"
+    return str(log_folder / log_filename)
+
+def set_log_file_path(inLogFolder: str = None, inLogFilename: str = None):
+    """
+    로그 파일의 경로를 동적으로 변경합니다.
+    
+    Args:
+        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)
+    
+    # 새 핸들러 추가
+    ue5_logger.addHandler(new_file_handler)
+    
+    ue5_logger.info(f"로그 파일 경로가 변경되었습니다: {log_file_path}")
+
+# 로깅 설정 완료 메시지
+ue5_logger.info("UE5 모듈 로깅 시스템 초기화 완료")