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

pyjallib/ue5/inUnreal/baseImporter.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+UE5 베이스 임포터 모듈
+UE5 에셋 임포트의 기본 기능을 제공하는 추상 클래스입니다.
+"""
+
+import json
+import os
+from pathlib import Path
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+from pyjallib.naming import Naming
+
+import unreal
+
+# UE5 모듈 import
+from .importerSettings import ImporterSettings
+from ..logger import ue5_logger
+
+class BaseImporter(ABC):
+    """모든 UE5 임포터의 베이스 클래스"""
+    
+    def __init__(self, inContentRootPrefix: str, inFbxRootPrefix: str, inPresetName: str):
+        self.contentRootPrefix = inContentRootPrefix
+        self.fbxRootPrefix = inFbxRootPrefix
+        self.importerSettings = ImporterSettings(
+            inContentRootPrefix=inContentRootPrefix, 
+            inFbxRootPrefix=inFbxRootPrefix, 
+            inPresetName=inPresetName
+        )
+        config_path = str(Path(__file__).parent.parent / "ConfigFiles" / "UE5NamingConfig.json")
+        self.naming = Naming(configPath=config_path)
+        ue5_logger.debug(f"BaseImporter 초기화: ContentRoot={inContentRootPrefix}, FbxRoot={inFbxRootPrefix}, Preset={inPresetName}")
+    
+    @property
+    @abstractmethod
+    def asset_type(self) -> str:
+        """에셋 타입을 반환하는 추상 프로퍼티"""
+        pass
+    
+    def convert_fbx_path_to_absolute_content_path(self, inFbxPath: str) -> str:
+        """
+        FBX 파일 경로를 UE5 Content 경로로 변환합니다.
+        fbxRootPrefix가 inFbxPath의 prefix일 경우, contentRootPrefix로 치환합니다.
+        Args:
+            inFbxPath (str): 변환할 FBX 파일 경로
+        Returns:
+            str: 변환된 Content 경로
+        """
+        ue5_logger.debug(f"FBX 경로 변환 시작: {inFbxPath}")
+        
+        fbxRoot = Path(self.fbxRootPrefix).resolve()
+        contentRoot = Path(self.contentRootPrefix).resolve()
+        fbxPath = Path(inFbxPath).resolve()
+
+        if str(fbxPath).startswith(str(fbxRoot)):
+            relative_path = fbxPath.relative_to(fbxRoot)
+            result_path = str(contentRoot / relative_path)
+            ue5_logger.debug(f"경로 변환 완료: {inFbxPath} -> {result_path}")
+            return result_path
+        else:
+            ue5_logger.error(f"입력 경로가 fbxRootPrefix로 시작하지 않습니다: {inFbxPath}")
+            return ""
+    
+    def convert_fbx_path_to_content_path(self, inFbxPath: str) -> str:
+        ue5_logger.debug(f"Content 경로 변환 시작: {inFbxPath}")
+        
+        absoluteContentPath = self.convert_fbx_path_to_absolute_content_path(inFbxPath)
+        if absoluteContentPath == "":
+            return ""
+        
+        # UE5 프로젝트의 Content 디렉토리 경로 가져오기
+        contentPath = unreal.Paths.convert_relative_path_to_full(unreal.Paths.project_content_dir())
+        
+        absoluteContentPathObj = Path(absoluteContentPath)
+        contentPathObj = Path(contentPath)
+        
+        # absoluteContentPath가 contentPath로 시작하는지 확인
+        if str(absoluteContentPathObj).startswith(str(contentPathObj)):
+            # contentPath 부분을 /Game/으로 직접 치환
+            relativePath = absoluteContentPathObj.relative_to(contentPathObj)
+            # pathlib을 사용하여 경로 정규화
+            normalizedPath = Path(relativePath).as_posix()
+            result_path = f"/Game/{normalizedPath}"
+            
+            # UE5 내장 함수를 사용하여 경로 정규화
+            normalizedResultPath = unreal.Paths.normalize_directory_name(result_path)
+            
+            ue5_logger.debug(f"Content 경로 변환 완료: {inFbxPath} -> {normalizedResultPath}")
+            return normalizedResultPath
+        else:
+            ue5_logger.error(f"절대 경로가 콘텐츠 디렉토리로 시작하지 않습니다: {absoluteContentPath}")
+            return ""
+        
+    def convert_fbx_path_to_skeleton_path(self, inFbxPath: str) -> str:
+        """
+        FBX 파일 경로를 스켈레톤 경로로 변환합니다.
+        fbxRootPrefix가 inFbxPath의 prefix일 경우, contentRootPrefix로 치환합니다.
+        """
+        skeletonPath = self.convert_fbx_path_to_content_path(inFbxPath)
+        if skeletonPath == "":
+            return ""
+        
+        destinationPath = unreal.Paths.get_path(skeletonPath)
+        assetName = unreal.Paths.get_base_filename(skeletonPath)
+        assetName = self.naming.replace_name_part("AssetType", assetName, self.naming.get_name_part("AssetType").get_value_by_description("Skeleton"))
+        skeletonFullPath = f"{destinationPath}/{assetName}"
+        return skeletonFullPath
+    
+    def _create_result_dict(self, inSourceFile: str, inPath: str, inName: str, inSuccess: bool = True):
+        """결과 딕셔너리를 생성하는 공통 메서드"""
+        result = {
+            "SourceFile": inSourceFile,
+            "Path": inPath,
+            "Name": inName,
+            "Type": self.asset_type,
+            "Success": inSuccess
+        }
+        ue5_logger.debug(f"결과 딕셔너리 생성: {result}")
+        return result
+    
+    def _prepare_import_paths(self, inFbxFile: str, inAssetName: str = None):
+        """임포트 경로를 준비하는 공통 메서드"""
+        ue5_logger.info(f"임포트 경로 준비 시작: {inFbxFile}")
+        
+        assetPath = self.convert_fbx_path_to_content_path(inFbxFile)
+        if assetPath == "":
+            error_msg = f"FBX 파일 경로가 올바르지 않습니다: {inFbxFile}"
+            ue5_logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        # 경로에서 파일명 분리
+        destinationPath = unreal.Paths.get_path(assetPath)
+        assetName = unreal.Paths.get_base_filename(assetPath)
+        
+        # 에셋 이름 결정: 입력된 이름이 있으면 사용, 없으면 FBX 파일 이름에서 확장자 제거
+        if inAssetName is not None:
+            assetName = inAssetName
+
+        ue5_logger.info(f"임포트 경로 정보: Destination={destinationPath}, AssetName={assetName}")
+
+        if not unreal.Paths.directory_exists(destinationPath):
+            ue5_logger.info(f"디렉토리 생성: {destinationPath}")
+            unreal.EditorAssetLibrary.make_directory(destinationPath)
+        
+        if unreal.Paths.file_exists(assetPath):
+            ue5_logger.info(f"기존 파일 체크아웃: {assetPath}")
+            unreal.SourceControl.check_out_or_add_file(assetPath)
+        
+        return destinationPath, assetName
+    
+    @abstractmethod
+    def create_import_task(self, inFbxFile: str, inDestinationPath: str):
+        """임포트 태스크를 생성하는 추상 메서드 - 각 임포터에서 구현"""
+        pass 
+    
+    def get_dirty_deps(self, inAssetPath: str):
+        returnList = []
+        
+        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(
+                include_soft_package_references=False,  # Soft reference 제외
+                include_hard_package_references=True,   # Hard reference만
+                include_searchable_names=False,
+                include_soft_management_references=False,
+                include_hard_management_references=False
+            )
+        )
+        
+        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/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)
+        
+        
+        
+        
+        
+        
+