pyjallib 0.1.16__py3-none-any.whl → 0.1.17__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,114 @@
+#!/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_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)
+        
+        # 임포트된 애니메이션 에셋의 시스템 경로 가져오기
+        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)
+        
+        animationSystemFullPath = unreal.SystemLibrary.get_system_path(importedAnimation)
+        importedObjectPaths.append(animationSystemFullPath)
+        
+        checkInDescription = f"Animation 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/baseImporter.py

@@ -0,0 +1,184 @@
+#!/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)
+        
+        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
+            )
+        )
+        
+        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