toolbar 개발 중

Assets/Scripts/UVC/Locale/LocalizationManager.cs

@@ -246,7 +246,7 @@ namespace UVC.Locale
             if (_dataSource?.Translations == null)
             {
                 ULog.Warning("Translations data source is not loaded. Cannot get string for key: " + key);
-                return $"[{key}]";
+                return key;
             }
 
             if (_dataSource.Translations.TryGetValue(_currentLanguage, out var languageSpecificStrings) &&
@@ -256,7 +256,7 @@ namespace UVC.Locale
             }
 
             ULog.Debug($"Translation for key '{key}' not found in language '{_currentLanguage}'.");
-            return $"[{key}]"; // 키를 그대로 반환하는 예시
+            return key; // 키를 그대로 반환
         }
 
         /// <summary>

Assets/Scripts/UVC/UI/Commands/ActionCommand.cs

@@ -0,0 +1,104 @@
+using System;
+using UnityEngine;
+
+namespace UVC.UI.Commands
+{
+    public class ActionCommand : ICommand
+    {
+        private readonly Action _action;
+        private readonly Action<object> _actionWithParam;
+
+        public ActionCommand(Action action)
+        {
+            _action = action ?? throw new ArgumentNullException(nameof(action));
+        }
+
+        public ActionCommand(Action<object> actionWithParam)
+        {
+            _actionWithParam = actionWithParam ?? throw new ArgumentNullException(nameof(actionWithParam));
+        }
+
+        public void Execute(object parameter = null)
+        {
+            _action?.Invoke();
+            _actionWithParam?.Invoke(parameter);
+        }
+    }
+
+    // 제네릭 ActionCommand<T>는 이미 파라미터를 생성자에서 받으므로,
+    // ICommand.Execute(object parameter)를 구현할 때 해당 파라미터를 사용하지 않거나,
+    // 혹은 Execute(object) 호출 시 전달된 파라미터로 내부 _parameter를 덮어쓰는 등의 정책을 정해야 합니다.
+    // 또는, ICommand<T> 인터페이스를 고려할 수도 있습니다 (아래 2번 방법).
+    public class ActionCommand<T> : ICommand<T> // ICommand<T>를 구현
+    {
+        private readonly Action<T> _action;
+        private readonly T _defaultParameter;
+        private bool _useDefaultParameterForParameterlessExecute;
+
+        public ActionCommand(Action<T> action)
+        {
+            _action = action ?? throw new ArgumentNullException(nameof(action));
+            _useDefaultParameterForParameterlessExecute = true; // 기본적으로 default(T) 사용
+            _defaultParameter = default(T);
+        }
+
+        public ActionCommand(Action<T> action, T defaultParameter, bool useDefaultForParameterless = true)
+        {
+            _action = action ?? throw new ArgumentNullException(nameof(action));
+            _defaultParameter = defaultParameter;
+            _useDefaultParameterForParameterlessExecute = useDefaultForParameterless;
+        }
+
+        // ICommand<T>의 Execute(T parameter) 구현
+        public void Execute(T parameter)
+        {
+            _action.Invoke(parameter);
+        }
+
+        // ICommand<T> 인터페이스에 의해 추가된 파라미터 없는 Execute()
+        // 기본 구현은 Execute(default(T))를 호출합니다.
+        // 이 메서드는 ICommand<T>의 기본 인터페이스 메서드에 의해 제공되므로,
+        // 여기서 명시적으로 재정의할 필요는 없습니다. (void ICommand<T>.Execute() => Execute(default(T));)
+        // 만약 다른 동작을 원한다면 여기서 재정의할 수 있습니다.
+        // public new void Execute() // 'new'는 인터페이스의 기본 구현을 숨기기 위함이 아님.
+        // {
+        //     if (_useDefaultParameterForParameterlessExecute)
+        //     {
+        //         _action.Invoke(_defaultParameter);
+        //     }
+        //     else
+        //     {
+        //         // 또는 예외를 발생시키거나, 로깅 후 아무것도 하지 않음
+        //         Debug.LogWarning($"ActionCommand<{typeof(T).Name}>의 파라미터 없는 Execute()가 호출되었으나, 기본 파라미터 사용이 설정되지 않았습니다.");
+        //     }
+        // }
+
+
+        // ICommand의 Execute(object parameter = null) 구현
+        void ICommand.Execute(object parameter) // 명시적 인터페이스 구현
+        {
+            if (parameter is T typedParameter)
+            {
+                Execute(typedParameter);
+            }
+            else if (parameter == null)
+            {
+                // 파라미터가 null로 전달된 경우, T의 기본값 또는 생성자에서 설정된 기본값을 사용할지 결정
+                if (_useDefaultParameterForParameterlessExecute)
+                {
+                    Execute(_defaultParameter);
+                }
+                else
+                {
+                    // T가 참조 타입이면 default(T)는 null. 값 타입이면 0, false 등.
+                    Execute(default(T));
+                }
+            }
+            else
+            {
+                Debug.LogError($"ActionCommand<{typeof(T).Name}>.Execute(object): 잘못된 파라미터 타입입니다. 기대: {typeof(T).Name}, 실제: {parameter.GetType().Name}");
+                // 예외를 발생시킬 수도 있습니다: throw new ArgumentException("잘못된 파라미터 타입입니다.", nameof(parameter));
+            }
+        }
+    }
+}

Assets/Scripts/UVC/UI/Commands/ActionCommand.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3f662cce09b4b4d48999758210c0ad4a

Assets/Scripts/UVC/UI/Commands/ChangeLanguageCommand.cs

@@ -1,4 +1,5 @@
-using UVC.Locale;
+using UnityEngine;
+using UVC.Locale;
 using UVC.Log;
 
 namespace UVC.UI.Commands
@@ -14,17 +15,33 @@ namespace UVC.UI.Commands
             _languageCode = languageCode;
         }
 
-        public void Execute()
+        public void Execute(object parameter = null)
         {
-            LocalizationManager _localizationManager = LocalizationManager.Instance;
-            if (_localizationManager != null)
+            string targetLanguage = _languageCode;
+
+            // Execute 호출 시 전달된 파라미터가 있다면 그것을 우선 사용
+            if (parameter is string langCodeFromParam && !string.IsNullOrEmpty(langCodeFromParam))
             {
-                _localizationManager.SetCurrentLanguage(_languageCode);
-                ULog.Debug($"언어가 {_languageCode}(으)로 변경되었습니다. (Command)");
+                targetLanguage = langCodeFromParam;
+                Debug.Log($"ChangeLanguageCommand: 파라미터로 언어 코드 '{targetLanguage}' 사용.");
+            }
+            else if (!string.IsNullOrEmpty(_languageCode))
+            {
+                Debug.Log($"ChangeLanguageCommand: 생성자에서 설정된 언어 코드 '{targetLanguage}' 사용.");
             }
             else
             {
-                ULog.Error("LocalizationManager가 ChangeLanguageCommand에 전달되지 않았습니다.");
+                Debug.LogError("ChangeLanguageCommand: 변경할 언어 코드가 지정되지 않았습니다.");
+                return;
+            }
+
+            if (LocalizationManager.Instance != null)
+            {
+                LocalizationManager.Instance.SetCurrentLanguage(targetLanguage);
+            }
+            else
+            {
+                Debug.LogError("LocalizationManager 인스턴스를 찾을 수 없습니다.");
             }
         }
     }

Assets/Scripts/UVC/UI/Commands/DebugLogCommand.cs

@@ -12,9 +12,14 @@ namespace UVC.UI.Commands
             _message = message;
         }
 
-        public void Execute()
+        public void Execute(object parameter = null)
         {
-            ULog.Debug(_message);
+            string finalMessage = _message;
+            if (parameter != null)
+            {
+                finalMessage += $", parameter: {parameter}";
+            }
+            ULog.Debug(finalMessage);
         }
     }
 }

Assets/Scripts/UVC/UI/Commands/ICommand.cs

@@ -2,6 +2,13 @@
 {
     public interface ICommand
     {
-        void Execute();
+        void Execute(object parameter = null);
+    }
+
+    public interface ICommand<T> : ICommand
+    {
+        void Execute(T parameter);
+
+        void Execute() => Execute(default(T)); // 기본 Execute 구현 제공 가능
     }
 }

Assets/Scripts/UVC/UI/Commands/Mono/ChangeLanguageCommandMono.cs

@@ -6,7 +6,7 @@ namespace UVC.UI.Commands.Mono
 {
     public class ChangeLanguageCommandMono : MonoBehaviourCommand
     {
-        public override void Execute()
+        public override void Execute(object parameter = null)
         {
             //언어가 2개 인경우 switch 시킴
             LocalizationManager _localizationManager = LocalizationManager.Instance;

Assets/Scripts/UVC/UI/Commands/Mono/MonoBehaviourCommand.cs

@@ -2,11 +2,14 @@
 
 namespace UVC.UI.Commands.Mono
 {
+    /// <summary>
+    /// Unity Inspector에서 버튼에 직접 할당할 수 있는 MonoBehaviour 기반의 명령 클래스입니다.
+    /// </summary>
     public class MonoBehaviourCommand : MonoBehaviour, ICommand
     {
         // MonoCommand는 MonoBehaviour를 상속받아 Unity의 생명주기를 활용할 수 있습니다.
         // ICommand 인터페이스를 구현하여 명령 패턴을 따릅니다.
-        public virtual void Execute()
+        public virtual void Execute(object parameter = null)
         {
             // 기본 실행 로직 (필요시 override 가능)
             Debug.Log("MonoCommand executed.");

Assets/Scripts/UVC/UI/Commands/Mono/QuitApplicationCommandMono.cs

@@ -5,7 +5,7 @@ namespace UVC.UI.Commands.Mono
 {
     public class QuitApplicationCommandMono : MonoBehaviourCommand
     {
-        public override void Execute()
+        public override void Execute(object parameter = null)
         {
             new QuitApplicationCommand().Execute();
         }

Assets/Scripts/UVC/UI/Commands/QuitApplicationCommand.cs

@@ -1,17 +1,26 @@
 using UnityEngine;
-using UVC.Log;
 
 namespace UVC.UI.Commands
 {
     // 애플리케이션 종료 커맨드
     public class QuitApplicationCommand : ICommand
     {
-        public void Execute()
+        public void Execute(object parameter = null)
         {
-            ULog.Debug("애플리케이션을 종료합니다.");
-            Application.Quit();
+            // 파라미터는 여기서는 사용되지 않을 수 있음
+            if (parameter != null)
+            {
+                Debug.Log($"QuitApplicationCommand 실행됨 (파라미터 무시됨: {parameter})");
+            }
+            else
+            {
+                Debug.Log("QuitApplicationCommand 실행됨");
+            }
+
 #if UNITY_EDITOR
-            UnityEditor.EditorApplication.isPlaying = false; // 에디터에서 실행 중일 경우 플레이 모드 종료
+            UnityEditor.EditorApplication.isPlaying = false;
+#else
+            Application.Quit();
 #endif
         }
     }

Assets/Scripts/UVC/UI/Menu/TopMenuController.cs

@@ -198,9 +198,13 @@ namespace UVC.UI.Menu
                 new MenuItemData("file_new", "menu_file_new", subMenuItems: new List<MenuItemData>
                 {
                     new MenuItemData("file_new_project", "menu_file_new_project", new DebugLogCommand("새 프로젝트 선택됨 (Command 실행)")),
-                    new MenuItemData("file_new_file", "menu_file_new_file", new DebugLogCommand("새 파일 선택됨 (Command 실행)"))
+                    new MenuItemData("file_new_file", "menu_file_new_file",
+                        new ActionCommand(() => Debug.Log("[SampleProject] 새 파일 선택됨")))
                 }),
-                new MenuItemData("file_open", "menu_file_open", new DebugLogCommand("파일 열기 선택됨 (Command 실행)"), isEnabled: false), // "파일 열기"는 비활성화 상태로 시작
+                new MenuItemData("file_open", "menu_file_open",
+                        new ActionCommand<string>((path) => Debug.Log($"[SampleProject] 파일 열기 선택됨: {path}"), "sample.txt"),
+                        commandParameter: "another_sample.txt", // 이 파라미터가 HandleMenuItemClicked에서 사용됨
+                        isEnabled: false), // "파일 열기"는 비활성화 상태로 시작
                 MenuItemData.CreateSeparator("file_sep1"), // 구분선 추가
                 new MenuItemData("file_save", "menu_file_save", command: new DebugLogCommand("저장 선택됨 (Command 실행)") , subMenuItems: new List<MenuItemData>
                 {
@@ -222,7 +226,7 @@ namespace UVC.UI.Menu
             model.MenuItems.Add(new MenuItemData("language", "menu_language", subMenuItems: new List<MenuItemData>
             {
                 // 각 언어 메뉴 아이템에 ChangeLanguageCommand를 연결하여 언어 변경 기능 수행
-                new MenuItemData("lang_ko", "menu_lang_korean", new ChangeLanguageCommand("ko-KR")),
+                new MenuItemData("lang_ko", "menu_lang_korean", new ChangeLanguageCommand("ko-KR"), commandParameter: "ko-KR"),
                 new MenuItemData("lang_en", "menu_lang_english", new ChangeLanguageCommand("en-US"))
                 // 필요에 따라 다른 언어들도 추가 가능
             }));
@@ -239,9 +243,13 @@ namespace UVC.UI.Menu
             // 클릭된 아이템이 구분선이거나 비활성화 상태인지 확인
             if (clickedItemData.IsSeparator)
             {
-                // 구분선은 아무 동작도 하지 않음
+                if (!clickedItemData.IsEnabled)
+                {
+                    Debug.Log($"비활성화된 메뉴 아이템 클릭 시도: {clickedItemData.ItemId} (표시 키: {clickedItemData.DisplayNameKey})");
+                }
                 return;
             }
+
             if (!clickedItemData.IsEnabled)
             {
                 // 비활성화된 아이템 클릭 시 로그 (디버깅 목적)
@@ -254,7 +262,7 @@ namespace UVC.UI.Menu
 
             // 메뉴 아이템에 연결된 Command가 있다면 실행
             // Command가 null일 수 있으므로 null 조건부 연산자(?.) 사용
-            clickedItemData.Command?.Execute();
+            clickedItemData.Command?.Execute(clickedItemData.CommandParameter);
         }
 
         /// <summary>

Assets/Scripts/UVC/UI/Menu/TopMenuModel.cs

@@ -16,7 +16,7 @@ namespace UVC.UI.Menu
         public string ItemId { get; private set; }
 
         /// <summary>
-        /// UI에 표시될 메뉴 아이템의 이름에 대한 다국어 처리 키입니다.
+        /// UI에 표시될 메뉴 아이템의 이름입니다. 다국어 키도 가능합니다.
         /// 이 키를 사용하여 실제 표시될 텍스트를 가져옵니다.
         /// </summary>
         public string DisplayNameKey { get; private set; }
@@ -28,6 +28,12 @@ namespace UVC.UI.Menu
         /// </summary>
         public ICommand Command { get; private set; }
 
+        /// <summary>
+        /// <see cref="Command"/> 실행 시 전달될 파라미터입니다.
+        /// 이 파라미터는 <see cref="TopMenuController.HandleMenuItemClicked"/>에서 <see cref="ICommand.Execute"/> 호출 시 사용될 수 있습니다.
+        /// </summary>
+        public object CommandParameter { get; set; }
+
         /// <summary>
         /// 이 메뉴 아이템에 속한 하위 메뉴 아이템들의 목록입니다.
         /// 하위 메뉴가 없는 경우 빈 리스트입니다.
@@ -51,16 +57,18 @@ namespace UVC.UI.Menu
         /// `MenuItemData` 클래스의 새 인스턴스를 초기화합니다.
         /// </summary>
         /// <param name="itemId">메뉴 아이템의 고유 ID.</param>
-        /// <param name="displayNameKey">표시 이름의 다국어 키.</param>
+        /// <param name="displayName">표시 이름. 표시 이름의 다국어 키도 가능.</param>
         /// <param name="command">실행할 명령 (선택 사항).</param>
+        /// <param name="commandParameter">커맨드에 전달할 파라미터 (선택 사항).</param>
         /// <param name="subMenuItems">하위 메뉴 아이템 목록 (선택 사항).</param>
         /// <param name="isSeparator">구분선 여부 (선택 사항, 기본값: false).</param>
         /// <param name="isEnabled">활성화 상태 (선택 사항, 기본값: true).</param>
-        public MenuItemData(string itemId, string displayNameKey, ICommand command = null, List<MenuItemData> subMenuItems = null, bool isSeparator = false, bool isEnabled = true)
+        public MenuItemData(string itemId, string displayName, ICommand command = null, object commandParameter = null, List<MenuItemData> subMenuItems = null, bool isSeparator = false, bool isEnabled = true)
         {
             ItemId = itemId;
-            DisplayNameKey = displayNameKey;
+            DisplayNameKey = displayName;
             Command = command;
+            CommandParameter = commandParameter; // 파라미터 저장
             SubMenuItems = subMenuItems ?? new List<MenuItemData>(); // null인 경우 빈 리스트로 초기화
             IsSeparator = isSeparator;
             IsEnabled = isEnabled;
@@ -85,7 +93,7 @@ namespace UVC.UI.Menu
         public static MenuItemData CreateSeparator(string itemId = null)
         {
             // 구분선은 특정 동작이나 표시 이름이 필요 없으므로, displayNameKey는 비워두고 command는 null로 설정합니다.
-            return new MenuItemData(itemId ?? $"separator_{Guid.NewGuid()}", string.Empty, null, null, true);
+            return new MenuItemData(itemId ?? $"separator_{Guid.NewGuid()}", string.Empty, null, null, null, true);
         }
     }
 

Assets/Scripts/UVC/UI/Menu/TopMenuView.cs

@@ -406,7 +406,7 @@ namespace UVC.UI.Menu
                         {
                             // LocalizationManager가 없는 경우, 키 값을 그대로 표시 (개발 중 확인 용도)
                             ULog.Warning($"LocalizationManager 인스턴스가 없어 메뉴 아이템 텍스트를 키 값으로 설정합니다: {itemData.DisplayNameKey}");
-                            buttonText.text = $"[{itemData.DisplayNameKey}]";
+                            buttonText.text = itemData.DisplayNameKey;
                         }
                     }
 

Assets/Scripts/UVC/UI/Modal/Alert.cs

@@ -37,10 +37,10 @@ namespace UVC.UI.Modal
         /// ✨ 지정된 제목과 메시지로 알림창을 화면에 뿅! 하고 보여줘요.
         /// 사용자가 "확인" 버튼을 누를 때까지 코드는 여기서 잠시 멈춰 기다려요.
         /// </summary>
-        /// <param name="title">알림창 맨 위에 크게 보일 '제목'이에요.</param>
-        /// <param name="message">알림창에 보여줄 '메시지 내용'이에요.</param>
-        /// <param name="confirmButtonText">"확인" 버튼에 보여줄 글자예요. 아무것도 안 적으면 기본 글자("확인" 또는 설정된 언어)가 나와요.</param>
-        /// <param name="customPrefabPath">만약 특별히 만들어둔 알림창 디자인이 있다면, 그 파일 경로를 여기에 적어주세요. 없으면 기본 디자인을 사용해요.</param>
+        /// <param name="title">알림창 맨 위에 크게 보일 '제목'이에요. 다국어 키도 가능해요.</param>
+        /// <param name="message">알림창에 보여줄 '메시지 내용'이에요. 다국어 키도 가능해요.</param>
+        /// <param name="confirmButtonText">"확인" 버튼에 보여줄 글자예요. 아무것도 안 적으면 기본 글자("확인" 또는 설정된 언어)가 나와요. 다국어 키도 가능해요.</param>
+        /// <param name="customPrefabPath">만약 특별히 만들어둔 알림창 디자인이 있다면, 그 파일 경로를 여기에 적어주세요. 없으면 기본 디자인을 사용해요. 다국어 키도 가능해요.</param>
         /// <returns>사용자가 확인 버튼을 누르면 완료되는 작업(UniTask)이에요. 특별한 값을 돌려주진 않아요.</returns>
         /// <example>
         /// <code>
@@ -61,6 +61,19 @@ namespace UVC.UI.Modal
         ///             await Alert.Show("저장 실패", "오류가 발생하여 저장하지 못했습니다.", "다시 시도");
         ///             // (다시 시도 로직 또는 다른 처리...)
         ///         }
+        ///         
+        ///         // 예시: 퀘스트 완료 메시지를 현재 설정된 언어로 보여줍니다.
+        ///         // titleLocalizationKey: "quest_completed_title" -> "퀘스트 완료" (한국어), "Quest Complete" (영어)
+        ///         // messageLocalizationKey: "quest_completed_message" -> "{0} 퀘스트를 완료했습니다!" (한국어), "You have completed the {0} quest!" (영어)
+        ///         // 여기서 {0} 부분은 실제 퀘스트 이름으로 바뀔 수 있도록 LocalizationManager에서 처리한다고 가정합니다.
+        ///         
+        ///         string localizedQuestName = LocalizationManager.Instance.GetString(questNameKey); // 예: "main_quest_01" -> "첫 번째 임무"
+        ///         string formattedMessageKey = "quest_completed_message"; // 실제로는 메시지 포맷팅이 필요할 수 있음
+        ///         
+        ///         // 실제 메시지는 LocalizationManager에서 포맷팅을 지원해야 함        
+        ///         // 여기서는 간단히 키만 전달하는 것으로 가정
+        ///         await Alert.Show("quest_completed_title", formattedMessageKey, confirmButtonLocalizationKey: "ui_button_great");
+        ///         ULog.Debug("퀘스트 완료 알림을 플레이어가 확인했습니다.");
         ///     }
         /// }
         /// </code>
@@ -76,15 +89,15 @@ namespace UVC.UI.Modal
             // ModalContent 레시피를 만들어요. 알림창은 취소 버튼이 필요 없으니 숨겨요.
             ModalContent content = new ModalContent(prefabPath)
             {
-                Title = title,
-                Message = message,
+                Title = LocalizationManager.Instance.GetString(title),
+                Message = LocalizationManager.Instance.GetString(message),
                 ShowCancelButton = false, // Alert에서는 취소 버튼 숨김
             };
 
             // 확인 버튼 글자를 따로 정해줬다면 그걸로 설정해요.
             if (!string.IsNullOrEmpty(confirmButtonText))
             {
-                content.ConfirmButtonText = confirmButtonText;
+                content.ConfirmButtonText = LocalizationManager.Instance.GetString(confirmButtonText);
             }
             // 아니면 ModalContent의 기본 설정(다국어 지원 "button_confirm" 키)을 따라요.
             // 만약 다른 기본 키를 쓰고 싶다면 여기서 설정할 수도 있어요.
@@ -94,57 +107,5 @@ namespace UVC.UI.Modal
             // Alert은 사용자의 선택 결과(true/false)가 중요하지 않으므로, bool 타입으로 받고 결과는 무시해요.
             await Modal.Open<bool>(content);
         }
-
-        /// <summary>
-        /// 🌍 다국어(여러 나라 언어)를 지원하는 알림창을 보여줘요.
-        /// 미리 준비된 '언어 키'를 알려주면, 게임 설정 언어에 맞는 글자를 자동으로 찾아서 보여줘요.
-        /// </summary>
-        /// <param name="titleLocalizationKey">제목에 사용할 '언어 키'예요. (예: "alert_title_welcome")</param>
-        /// <param name="messageLocalizationKey">메시지 내용에 사용할 '언어 키'예요. (예: "alert_message_item_acquired")</param>
-        /// <param name="confirmButtonLocalizationKey">확인 버튼 글자에 사용할 '언어 키'예요. 안 적으면 기본 키("button_confirm")를 사용해요.</param>
-        /// <param name="customPrefabPath">특별한 알림창 디자인 파일 경로예요. 없으면 기본 디자인을 사용해요.</param>
-        /// <returns>사용자가 확인 버튼을 누르면 완료되는 작업(UniTask)이에요.</returns>
-        /// <example>
-        /// <code>
-        /// public class QuestManager : MonoBehaviour
-        /// {
-        ///     public async void OnQuestCompleted(string questNameKey)
-        ///     {
-        ///         // 예시: 퀘스트 완료 메시지를 현재 설정된 언어로 보여줍니다.
-        ///         // titleLocalizationKey: "quest_completed_title" -> "퀘스트 완료" (한국어), "Quest Complete" (영어)
-        ///         // messageLocalizationKey: "quest_completed_message" -> "{0} 퀘스트를 완료했습니다!" (한국어), "You have completed the {0} quest!" (영어)
-        ///         // 여기서 {0} 부분은 실제 퀘스트 이름으로 바뀔 수 있도록 LocalizationManager에서 처리한다고 가정합니다.
-        ///
-        ///         string localizedQuestName = LocalizationManager.Instance.GetString(questNameKey); // 예: "main_quest_01" -> "첫 번째 임무"
-        ///         string formattedMessageKey = "quest_completed_message"; // 실제로는 메시지 포맷팅이 필요할 수 있음
-        ///
-        ///         // 실제 메시지는 LocalizationManager에서 포맷팅을 지원해야 함
-        ///         // 여기서는 간단히 키만 전달하는 것으로 가정
-        ///         await Alert.ShowLocalized("quest_completed_title", formattedMessageKey, confirmButtonLocalizationKey: "ui_button_great");
-        ///         ULog.Debug("퀘스트 완료 알림을 플레이어가 확인했습니다.");
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        public static async UniTask ShowLocalized(
-            string titleLocalizationKey,
-            string messageLocalizationKey,
-            string confirmButtonLocalizationKey = null,
-            string customPrefabPath = null)
-        {
-            // 언어 키를 사용해서 실제 보여줄 글자들을 가져와요.
-            string title = LocalizationManager.Instance.GetString(titleLocalizationKey);
-            string message = LocalizationManager.Instance.GetString(messageLocalizationKey);
-            string confirmText = null;
-
-            if (!string.IsNullOrEmpty(confirmButtonLocalizationKey))
-            {
-                confirmText = LocalizationManager.Instance.GetString(confirmButtonLocalizationKey);
-            }
-            // confirmText가 null (따로 안 정해줬으면)이면, Show() 메서드 안에서 ModalContent의 기본 글자 로직이 알아서 처리해줘요.
-
-            // 준비된 글자들로 알림창을 보여달라고 Show()에게 다시 부탁해요.
-            await Show(title, message, confirmText, customPrefabPath);
-        }
     }
 }

Assets/Scripts/UVC/UI/Modal/Confirm.cs

@@ -54,12 +54,12 @@ namespace UVC.UI.Modal
         /// ✨ 지정된 제목과 메시지로 확인창을 화면에 뿅! 하고 보여줘요.
         /// 사용자가 "확인" 또는 "취소" 버튼을 누를 때까지 코드는 여기서 잠시 멈춰 기다려요.
         /// </summary>
-        /// <param name="title">확인창 맨 위에 크게 보일 '제목'이에요.</param>
-        /// <param name="message">확인창에 보여줄 '질문 또는 메시지 내용'이에요.</param>
-        /// <param name="confirmButtonText">"확인" 버튼에 보여줄 글자예요. 안 적으면 기본 글자("확인")가 나와요.</param>
-        /// <param name="cancelButtonText">"취소" 버튼에 보여줄 글자예요. 안 적으면 기본 글자("취소")가 나와요.</param>
-        /// <param name="customPrefabPath">특별히 만들어둔 확인창 디자인 파일 경로예요. 없으면 기본 디자인을 사용해요.</param>
-        /// <returns>사용자가 "확인"을 누르면 true, "취소"를 누르면 false를 돌려주는 작업(UniTask&lt;bool&gt;)이에요.</returns>
+        /// <param name="title">확인창 맨 위에 크게 보일 '제목'이에요. 다국어 키도 가능해요.</param>
+        /// <param name="message">확인창에 보여줄 '질문 또는 메시지 내용'이에요. 다국어 키도 가능해요.</param>
+        /// <param name="confirmButtonText">"확인" 버튼에 보여줄 글자예요. 안 적으면 기본 글자("확인")가 나와요. 다국어 키도 가능해요.</param>
+        /// <param name="cancelButtonText">"취소" 버튼에 보여줄 글자예요. 안 적으면 기본 글자("취소")가 나와요. 다국어 키도 가능해요.</param>
+        /// <param name="customPrefabPath">특별히 만들어둔 확인창 디자인 파일 경로예요. 없으면 기본 디자인을 사용해요. 다국어 키도 가능해요.</param>
+        /// <returns>사용자가 "확인"을 누르면 true, "취소"를 누르면 false를 돌려주는 작업(UniTask<bool>)이에요.</returns>
         /// <example>
         /// <code>
         /// public class ShopManager : MonoBehaviour
@@ -80,60 +80,7 @@ namespace UVC.UI.Modal
         ///         {
         ///             ULog.Debug($"{itemName} 구매를 취소했습니다.");
         ///         }
-        ///     }
-        /// }
-        /// </code>
-        /// </example>
-        public static async UniTask<bool> Show(
-            string title,
-            string message,
-            string confirmButtonText = null,
-            string cancelButtonText = null,
-            string customPrefabPath = null)
-        {
-            string prefabPath = string.IsNullOrEmpty(customPrefabPath) ? DefaultPrefabPath : customPrefabPath;
-
-            // ModalContent 레시피를 만들어요. 확인창은 확인/취소 버튼이 모두 필요해요.
-            ModalContent content = new ModalContent(prefabPath)
-            {
-                Title = title,
-                Message = message,
-                ShowConfirmButton = true, // Confirm에서는 확인 버튼 항상 표시
-                ShowCancelButton = true   // Confirm에서는 취소 버튼 항상 표시
-            };
-
-            // 확인 버튼 글자를 따로 정해줬다면 그걸로 설정해요.
-            if (!string.IsNullOrEmpty(confirmButtonText))
-            {
-                content.ConfirmButtonText = confirmButtonText;
-            }
-
-            // 취소 버튼 글자를 따로 정해줬다면 그걸로 설정해요.
-            if (!string.IsNullOrEmpty(cancelButtonText))
-            {
-                content.CancelButtonText = cancelButtonText;
-            }
-
-            // Modal 시스템에게 "이 레시피대로 모달 창 열어줘!" 라고 부탁하고, 사용자의 선택(true/false)을 기다려요.
-            return await Modal.Open<bool>(content);
-        }
-
-        /// <summary>
-        /// 🌍 다국어(여러 나라 언어)를 지원하는 확인창을 보여줘요.
-        /// 미리 준비된 '언어 키'를 알려주면, 게임 설정 언어에 맞는 글자를 자동으로 찾아서 보여줘요.
-        /// </summary>
-        /// <param name="titleLocalizationKey">제목에 사용할 '언어 키'예요. (예: "confirm_title_exit_game")</param>
-        /// <param name="messageLocalizationKey">메시지 내용에 사용할 '언어 키'예요. (예: "confirm_message_are_you_sure")</param>
-        /// <param name="confirmButtonLocalizationKey">확인 버튼 글자에 사용할 '언어 키'예요. 안 적으면 기본 키("button_confirm")를 사용해요.</param>
-        /// <param name="cancelButtonLocalizationKey">취소 버튼 글자에 사용할 '언어 키'예요. 안 적으면 기본 키("button_cancel")를 사용해요.</param>
-        /// <param name="customPrefabPath">특별한 확인창 디자인 파일 경로예요. 없으면 기본 디자인을 사용해요.</param>
-        /// <returns>사용자가 "확인"을 누르면 true, "취소"를 누르면 false를 돌려주는 작업(UniTask&lt;bool&gt;)이에요.</returns>
-        /// <example>
-        /// <code>
-        /// public class SettingsManager : MonoBehaviour
-        /// {
-        ///     public async void OnResetSettings()
-        ///     {
+        ///         
         ///         // 예시: 설정 초기화 전에 다국어로 확인을 받습니다.
         ///         // titleLocalizationKey: "settings_reset_title" -> "설정 초기화" (한국어), "Reset Settings" (영어)
         ///         // messageLocalizationKey: "settings_reset_confirm_message" -> "모든 설정을 초기화하시겠습니까?" (한국어), "Are you sure you want to reset all settings?" (영어)
@@ -154,35 +101,43 @@ namespace UVC.UI.Modal
         ///         {
         ///             ULog.Debug("설정 초기화를 취소했습니다.");
         ///         }
+        /// 
         ///     }
         /// }
         /// </code>
         /// </example>
-        public static async UniTask<bool> ShowLocalized(
-            string titleLocalizationKey,
-            string messageLocalizationKey,
-            string confirmButtonLocalizationKey = null,
-            string cancelButtonLocalizationKey = null,
+        public static async UniTask<bool> Show(
+            string title,
+            string message,
+            string confirmButtonText = null,
+            string cancelButtonText = null,
             string customPrefabPath = null)
         {
-            // 언어 키를 사용해서 실제 보여줄 글자들을 가져와요.
-            string title = LocalizationManager.Instance.GetString(titleLocalizationKey);
-            string message = LocalizationManager.Instance.GetString(messageLocalizationKey);
-            string confirmText = null;
-            string cancelText = null;
+            string prefabPath = string.IsNullOrEmpty(customPrefabPath) ? DefaultPrefabPath : customPrefabPath;
 
-            if (!string.IsNullOrEmpty(confirmButtonLocalizationKey))
+            // ModalContent 레시피를 만들어요. 확인창은 확인/취소 버튼이 모두 필요해요.
+            ModalContent content = new ModalContent(prefabPath)
             {
-                confirmText = LocalizationManager.Instance.GetString(confirmButtonLocalizationKey);
+                Title = LocalizationManager.Instance.GetString(title),
+                Message = LocalizationManager.Instance.GetString(message),
+                ShowConfirmButton = true, // Confirm에서는 확인 버튼 항상 표시
+                ShowCancelButton = true   // Confirm에서는 취소 버튼 항상 표시
+            };
+
+            // 확인 버튼 글자를 따로 정해줬다면 그걸로 설정해요.
+            if (!string.IsNullOrEmpty(confirmButtonText))
+            {
+                content.ConfirmButtonText = LocalizationManager.Instance.GetString(confirmButtonText);
             }
 
-            if (!string.IsNullOrEmpty(cancelButtonLocalizationKey))
+            // 취소 버튼 글자를 따로 정해줬다면 그걸로 설정해요.
+            if (!string.IsNullOrEmpty(cancelButtonText))
             {
-                cancelText = LocalizationManager.Instance.GetString(cancelButtonLocalizationKey);
+                content.CancelButtonText = LocalizationManager.Instance.GetString(cancelButtonText);
             }
 
-            // 준비된 글자들로 확인창을 보여달라고 Show()에게 다시 부탁하고, 사용자의 선택을 기다려요.
-            return await Show(title, message, confirmText, cancelText, customPrefabPath);
+            // Modal 시스템에게 "이 레시피대로 모달 창 열어줘!" 라고 부탁하고, 사용자의 선택(true/false)을 기다려요.
+            return await Modal.Open<bool>(content);
         }
     }
 }

Assets/Scripts/UVC/UI/Modal/ModalContent.cs

@@ -20,7 +20,7 @@ namespace UVC.UI.Modal
     /// };
     ///
     /// // 이렇게 만든 레시피(myRecipe)를 Modal.Open()에 전달하면 모달이 뿅 나타나요!
-    /// // bool userChoseConfirm = await Modal.Open<bool>(myRecipe);
+    /// // bool userChoseConfirm = await Modal.Open<bool>(myRecipe);
     /// </code>
     /// </example>
     public class ModalContent
@@ -37,11 +37,12 @@ namespace UVC.UI.Modal
         /// </summary>
         public string Message { get; set; }
 
-        private string _confirmButtonText;
+        private string _confirmButtonText = "확인";
         /// <summary>
         /// ✅ '확인' 버튼에 보여줄 글자예요.
         /// 특별히 정해주지 않으면 기본적으로 "확인" (또는 설정된 언어에 맞게)이라고 나와요.
         /// 직접 "네", "저장하기", "출발!" 처럼 원하는 글자로 바꿀 수 있어요.
+        /// 다국어 키를 사용해서 설정할 수도 있어요. (예: "ui_button_confirm", "action_ok")
         /// </summary>
         public string ConfirmButtonText
         {
@@ -50,19 +51,20 @@ namespace UVC.UI.Modal
                 // _confirmButtonText가 명시적으로 설정되지 않았고, LocalizationManager 사용이 가능하다면 번역된 문자열을 반환
                 if (string.IsNullOrEmpty(_confirmButtonText) && LocalizationManager.Instance != null)
                 {
-                    return LocalizationManager.Instance.GetString("button_confirm");
+                    return LocalizationManager.Instance.GetString(_confirmButtonText);
                 }
                 // 명시적으로 설정된 값이 있거나 LocalizationManager를 사용할 수 없다면 해당 값 또는 기본 키 반환
-                return !string.IsNullOrEmpty(_confirmButtonText) ? _confirmButtonText : "[button_confirm]";
+                return _confirmButtonText;
             }
             set => _confirmButtonText = value;
         }
 
-        private string _cancelButtonText;
+        private string _cancelButtonText = "취소";
         /// <summary>
         /// ❌ '취소' 버튼에 보여줄 글자예요.
         /// 특별히 정해주지 않으면 기본적으로 "취소" (또는 설정된 언어에 맞게)이라고 나와요.
         /// 직접 "아니요", "닫기", "나중에" 처럼 원하는 글자로 바꿀 수 있어요.
+        /// 다국어 키를 사용해서 설정할 수도 있어요. (예: "ui_button_cancel", "action_no")
         /// </summary>
         public string CancelButtonText
         {
@@ -71,10 +73,10 @@ namespace UVC.UI.Modal
                 // _cancelButtonText가 명시적으로 설정되지 않았고, LocalizationManager 사용이 가능하다면 번역된 문자열을 반환
                 if (string.IsNullOrEmpty(_cancelButtonText) && LocalizationManager.Instance != null)
                 {
-                    return LocalizationManager.Instance.GetString("button_cancel");
+                    return LocalizationManager.Instance.GetString(_cancelButtonText);
                 }
                 // 명시적으로 설정된 값이 있거나 LocalizationManager를 사용할 수 없다면 해당 값 또는 기본 키 반환
-                return !string.IsNullOrEmpty(_cancelButtonText) ? _cancelButtonText : "[button_cancel]";
+                return _cancelButtonText;
             }
             set => _cancelButtonText = value;
         }
@@ -122,46 +124,7 @@ namespace UVC.UI.Modal
             PrefabPath = prefabPath;
             // Title, Message 등 다른 텍스트 속성도 필요한 경우 여기서 기본 다국어 키를 사용하여 초기화할 수 있습니다.
             // 예: Title = LocalizationManager.Instance.GetString("default_modal_title");
-        }
-
-        /// <summary>
-        /// 🔑 '확인' 버튼의 글자를 다국어 키를 사용해서 설정해요.
-        /// 게임이 여러 언어를 지원할 때 유용해요.
-        /// </summary>
-        /// <param name="localizationKey">미리 정해둔 다국어 키 (예: "ui_button_yes", "action_save")</param>
-        public void SetConfirmButtonTextFromKey(string localizationKey)
-        {
-            // 직접 값을 설정하는 대신, 키를 저장하고 getter에서 처리하도록 할 수도 있으나,
-            // 현재 구조에서는 setter를 통해 LocalizationManager.GetString을 호출하는 것이 더 간단합니다.
-            // 다만, 이 경우 인스턴스 생성 시점의 언어에 고정될 수 있으므로,
-            // 아래와 같이 getter에서 매번 가져오도록 하는 것이 언어 변경에 동적으로 반응합니다.
-            // 여기서는 명시적 설정을 위해 _confirmButtonText를 사용합니다.
-            // 만약 항상 최신 언어를 반영해야 한다면, _confirmButtonTextKey 와 같은 필드를 두고 getter에서 처리해야 합니다.
-            if (LocalizationManager.Instance != null)
-            {
-                _confirmButtonText = LocalizationManager.Instance.GetString(localizationKey);
-            }
-            else
-            {
-                _confirmButtonText = $"[{localizationKey}]";
-            }
-        }
-
-        /// <summary>
-        /// 🔑 '취소' 버튼의 글자를 다국어 키를 사용해서 설정해요.
-        /// </summary>
-        /// <param name="localizationKey">미리 정해둔 다국어 키 (예: "ui_button_no", "action_cancel")</param>
-        public void SetCancelButtonTextFromKey(string localizationKey)
-        {
-            if (LocalizationManager.Instance != null)
-            {
-                _cancelButtonText = LocalizationManager.Instance.GetString(localizationKey);
-            }
-            else
-            {
-                _cancelButtonText = $"[{localizationKey}]";
-            }
-        }
+        }        
 
         /// <summary>
         /// 🚀 모달 창이 화면에 나타나기 *직전*에 이 레시피가 할 일을 정해요. (비동기 작업 가능)

Assets/Scripts/UVC/UI/ToolBar/IToolbarItem.cs

@@ -1,4 +1,4 @@
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 툴바에 추가될 수 있는 모든 항목(버튼, 구분선 등)의 기본 인터페이스입니다.

Assets/Scripts/UVC/UI/ToolBar/ToolbarButtonBase.cs

@@ -1,7 +1,8 @@
 using System;
 using UnityEngine;
+using UVC.UI.Commands;
 
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 모든 버튼의 기본 추상 클래스입니다.
@@ -11,7 +12,7 @@ namespace UVC.UI.ToolBar
     {
         public event Action OnStateChanged; // 상태 변경 알림 이벤트
 
-        private string _text;
+        protected string _text;
         public string Text
         {
             get => _text;
@@ -25,21 +26,21 @@ namespace UVC.UI.ToolBar
             }
         }
 
-        private Sprite _icon;
-        public Sprite Icon
+        protected string _iconSpritePath;
+        public string IconSpritePath
         {
-            get => _icon;
+            get => _iconSpritePath;
             set
             {
-                if (_icon != value)
+                if (_iconSpritePath != value)
                 {
-                    _icon = value;
+                    _iconSpritePath = value;
                     OnStateChanged?.Invoke();
                 }
             }
         }
 
-        private bool _isEnabled = true;
+        protected bool _isEnabled = true;
         public bool IsEnabled
         {
             get => _isEnabled;
@@ -53,7 +54,7 @@ namespace UVC.UI.ToolBar
             }
         }
 
-        private string _tooltipKey; // 툴팁 다국어 키
+        protected string _tooltipKey; // 툴팁 다국어 키
         public string TooltipKey
         {
             get => _tooltipKey;
@@ -69,9 +70,20 @@ namespace UVC.UI.ToolBar
             }
         }
 
-        public Action OnClick { get; set; }
+        public ICommand ClickCommand { get; set; }
 
-        public abstract void ExecuteClick();
+        /// <summary>
+        /// 버튼 클릭 로직을 실행합니다.
+        /// 이 메서드는 일반적으로 UI 이벤트에 의해 호출됩니다.
+        /// </summary>
+        /// <param name="parameter">커맨드에 전달할 파라미터입니다.</param>
+        public virtual void ExecuteClick(object parameter = null)
+        {
+            if (IsEnabled && ClickCommand != null)
+            {
+                ClickCommand.Execute(parameter); // 커맨드에 파라미터 전달
+            }
+        }
 
         // OnStateChanged 이벤트를 외부에서 강제로 발생시켜야 할 때 사용 (예: 복합적인 상태 변경 후)
         public void NotifyStateChanged()

Assets/Scripts/UVC/UI/ToolBar/ToolbarExpandableButton.cs

@@ -3,7 +3,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 클릭 시 하위 버튼 그룹을 확장하여 보여주는 버튼입니다.
@@ -22,12 +22,22 @@ namespace UVC.UI.ToolBar
             SubButtons = new List<ToolbarButtonBase>();
         }
 
-        public override void ExecuteClick()
+        // 주 버튼 클릭 시 하위 메뉴를 토글하는 동작은 View에서 처리될 수 있고,
+        // ClickCommand는 주 버튼 자체의 액션(있다면)을 정의합니다.
+        // 또는 ClickCommand가 하위 메뉴 토글 로직을 포함할 수도 있습니다.
+        // 여기서는 ClickCommand는 주 버튼의 고유 액션, 하위 메뉴 토글은 View의 역할로 가정합니다.
+        public override void ExecuteClick(object parameter = null)
         {
-            if (IsEnabled)
-            {
-                OnClick?.Invoke();
-            }
+            if (!IsEnabled) return;
+
+            // ClickCommand는 주 버튼 자체의 액션 (예: 상태 변경, 특정 기능 수행)
+            ClickCommand?.Execute(parameter);
+
+            // 하위 메뉴를 여는 동작은 보통 View에서 이 버튼 클릭 시 별도로 처리합니다.
+            // OnClick (이제 ClickCommand)이 그 역할을 할 수도 있지만,
+            // View에서 직접 ToggleSubMenu를 호출하는 것이 더 명확할 수 있습니다.
+            // ToolbarView의 SetupButtonVisualsAndInteractions에서 expandableModel.ExecuteClick() 후
+            // ToggleSubMenu()를 호출하는 현재 구조를 유지할 수 있습니다.
         }
 
         public void SelectSubButton(ToolbarButtonBase selectedSubButton)
@@ -40,9 +50,9 @@ namespace UVC.UI.ToolBar
                     this.Text = selectedSubButton.Text; // Setter가 OnStateChanged 호출 (단, Text가 실제로 변경되어야 함)
                     changed = true;
                 }
-                if (this.Icon != selectedSubButton.Icon)
+                if (this.IconSpritePath != selectedSubButton.IconSpritePath)
                 {
-                    this.Icon = selectedSubButton.Icon; // Setter가 OnStateChanged 호출
+                    this.IconSpritePath = selectedSubButton.IconSpritePath; // Setter가 OnStateChanged 호출
                     changed = true;
                 }
 

Assets/Scripts/UVC/UI/ToolBar/ToolbarManager.cs

@@ -1,100 +0,0 @@
-using UnityEngine;
-using UVC.Locale;
-
-namespace UVC.UI.ToolBar
-{
-    public class ToolbarManager : MonoBehaviour
-    {
-        public Toolbar mainToolbar;
-        public ToolbarView mainToolbarView; // Unity 에디터에서 할당
-        public Transform toolbarContainer;  // Unity 에디터에서 할당 (툴바 UI가 생성될 부모)
-                                            // 여기에 HorizontalLayoutGroup 또는 VerticalLayoutGroup을 추가하는 것을 권장합니다.
-
-        // 버튼 프리팹들은 ToolbarView로 옮겨서 관리하는 것이 더 깔끔할 수 있습니다.
-        // 현재는 ToolbarManager에서 할당하여 ToolbarView로 전달하는 방식입니다.
-        public GameObject standardButtonPrefab;
-        public GameObject toggleButtonPrefab;
-        public GameObject radioButtonPrefab;
-        public GameObject expandableButtonPrefab;
-        public GameObject separatorPrefab;
-        public GameObject subMenuPanelPrefab;
-
-
-        void Start()
-        {
-            mainToolbar = new Toolbar();
-
-            // ToolbarView에 프리팹 설정
-            if (mainToolbarView != null)
-            {
-                mainToolbarView.standardButtonPrefab = standardButtonPrefab;
-                mainToolbarView.toggleButtonPrefab = toggleButtonPrefab;
-                mainToolbarView.radioButtonPrefab = radioButtonPrefab;
-                mainToolbarView.expandableButtonPrefab = expandableButtonPrefab;
-                mainToolbarView.separatorPrefab = separatorPrefab;
-                mainToolbarView.subMenuPanelPrefab = subMenuPanelPrefab;
-            }
-            else
-            {
-                Debug.LogError("ToolbarView가 할당되지 않았습니다.");
-                return;
-            }
-
-            // --- 툴바 모델 구성 ---
-            // "저장" 대신 다국어 키 "button_save" 사용
-            mainToolbar.AddStandardButton("button_save", null, () => Debug.Log("저장 버튼 클릭됨"), "tooltip_save_button");
-
-            // "음소거" 대신 다국어 키 "button_mute" 사용
-            mainToolbar.AddToggleButton("button_mute", false, null, (isSelected) => Debug.Log($"음소거: {isSelected}"), "tooltip_mute_button");
-
-            mainToolbar.AddSeparator();
-
-            // "펜" 대신 다국어 키 "tool_pen" 사용
-            mainToolbar.AddRadioButton("ToolGroup", "tool_pen", true, null, (isSelected) => { if (isSelected) Debug.Log("펜 도구 선택됨"); }, "tooltip_pen_tool");
-            // "지우개" 대신 다국어 키 "tool_eraser" 사용
-            mainToolbar.AddRadioButton("ToolGroup", "tool_eraser", false, null, (isSelected) => { if (isSelected) Debug.Log("지우개 도구 선택됨"); }, "tooltip_eraser_tool");
-
-            mainToolbar.AddSeparator();
-
-            // "브러시 크기" 대신 다국어 키 "button_brush_size" 사용
-            var expandableBtnModel = mainToolbar.AddExpandableButton("button_brush_size", null, null, "tooltip_brush_size");
-            // 하위 버튼도 다국어 키 사용
-            var smallBrush = new ToolbarStandardButton { Text = "brush_size_small", TooltipKey = "tooltip_brush_small" };
-            expandableBtnModel.SubButtons.Add(smallBrush);
-            expandableBtnModel.SubButtons.Add(new ToolbarStandardButton { Text = "brush_size_medium", TooltipKey = "tooltip_brush_medium" });
-            expandableBtnModel.OnSubButtonSelected = (selectedSubButton) => {
-                // selectedSubButton.Text 에는 이제 다국어 키가 들어있습니다.
-                // 실제 표시된 텍스트를 로그로 남기려면 LocalizationManager를 사용해야 합니다.
-                string localizedSubButtonText = LocalizationManager.Instance != null ? LocalizationManager.Instance.GetString(selectedSubButton.Text) : selectedSubButton.Text;
-                Debug.Log($"브러시 크기 '{localizedSubButtonText}' 선택됨 (주 버튼 업데이트)");
-            };
-            // --- 툴바 모델 구성 끝 ---
-
-
-            // ToolbarView 초기화 및 렌더링
-            if (toolbarContainer != null)
-            {
-                mainToolbarView.Initialize(mainToolbar, toolbarContainer);
-            }
-            else
-            {
-                Debug.LogError("ToolbarContainer가 할당되지 않았습니다.");
-            }
-
-            // 예시: 모델 상태를 코드로 변경하고 UI가 업데이트되는지 테스트
-            // StartCoroutine(TestModelChange(saveBtnModel, muteToggleModel));
-        }
-
-        // System.Collections.IEnumerator TestModelChange(ToolbarStandardButton standard, ToolbarToggleButton toggle)
-        // {
-        //     yield return new WaitForSeconds(2f);
-        //     Debug.Log("모델 변경 테스트: 저장 버튼 비활성화 및 텍스트 변경");
-        //     standard.Text = "저장됨";
-        //     standard.IsEnabled = false;
-        //
-        //     yield return new WaitForSeconds(2f);
-        //     Debug.Log("모델 변경 테스트: 음소거 토글 상태 변경");
-        //     toggle.IsSelected = true;
-        // }
-    }
-}

Assets/Scripts/UVC/UI/ToolBar/ToolbarRadioButton.cs

@@ -1,4 +1,4 @@
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 라디오 버튼 그룹 내에서 사용되는 버튼입니다.
@@ -14,19 +14,46 @@
             GroupName = groupName;
         }
 
-        public override void ExecuteClick()
+        public override void ExecuteClick(object parameter = null)
         {
-            if (IsEnabled)
+            if (!IsEnabled) return;
+
+            bool wasSelected = IsSelected;
+
+            if (RadioGroup != null)
             {
-                // 라디오 버튼은 직접 IsSelected를 토글하지 않고, 그룹에 의해 상태가 결정됩니다.
-                // 그룹이 SetSelected를 호출하면, 해당 버튼의 IsSelected가 true로 설정되고,
-                // 다른 버튼들은 false로 설정되면서 각자의 OnStateChanged 이벤트가 발생합니다.
-                RadioGroup?.SetSelected(this);
-                // OnClick은 그룹에 의해 선택이 확정되었을 때 호출되도록 RadioGroup.SetSelected 내부에서 처리하거나,
-                // 여기서 IsSelected 상태를 확인 후 호출할 수 있습니다.
-                // 현재 구조에서는 RadioGroup.SetSelected가 IsSelected를 변경하고, IsSelected의 setter가 OnStateChanged를 호출합니다.
-                // OnClick은 ToolbarToggleButton의 ExecuteClick에서 이미 호출될 수 있으므로 중복 호출을 피하거나 의도에 맞게 조정합니다.
+                // SetSelected는 IsSelected 상태를 변경하고,
+                // IsSelected setter는 OnToggleStateChanged 및 NotifyStateChanged를 호출합니다.
+                // OnToggle 콜백도 IsSelected setter 내부 또는 SetSelected 메서드 내에서 호출될 수 있습니다.
+                RadioGroup.SetSelected(this);
             }
+            else
+            {
+                // 그룹이 없는 라디오 버튼은 의미가 모호하므로, 단독으로 선택되는 것을 방지하거나 특별 처리.
+                // 여기서는 그룹이 없으면 아무것도 하지 않거나, 경고를 로깅할 수 있습니다.
+                UnityEngine.Debug.LogWarning($"ToolbarRadioButton '{Text}' (그룹: {GroupName})에 RadioGroup이 할당되지 않았습니다.");
+                // 또는 강제로 선택 상태로 만들고 콜백 호출 (기존 주석 참고)
+                // if (!IsSelected) // 현재 선택되지 않았다면 선택
+                // {
+                //     IsSelected = true; 
+                //     OnToggle?.Invoke(IsSelected);
+                // }
+            }
+
+            // ClickCommand 실행
+            // RadioGroup.SetSelected에 의해 IsSelected 상태가 변경된 후 실행됩니다.
+            // parameter가 null이 아니면 그것을 우선 사용하고, 아니면 현재 IsSelected 상태를 전달할 수 있습니다.
+            // 또는 버튼 자체를 파라미터로 전달하여 Command가 필요한 정보를 추출하도록 할 수도 있습니다.
+            object commandParameterToUse = parameter ?? this; // 예: 파라미터가 없으면 버튼 인스턴스 전달
+
+            // 라디오 버튼의 경우, ClickCommand는 주로 해당 버튼이 "선택되었을 때"의 액션을 정의합니다.
+            // 따라서 IsSelected가 true일 때만 Command를 실행하는 것이 일반적일 수 있습니다.
+            if (IsSelected) // 현재 버튼이 선택된 상태일 때만 Command 실행
+            {
+                ClickCommand?.Execute(commandParameterToUse);
+            }
+            // 만약 선택 해제 시에도 Command를 실행해야 한다면 위 if 조건을 제거합니다.
+            // 혹은, 선택/해제 상태 모두에 대해 Command를 실행하되, Command 내부에서 IsSelected 값을 확인하도록 합니다.
         }
     }
 }

Assets/Scripts/UVC/UI/ToolBar/ToolbarRadioButtonGroup.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 라디오 버튼들을 그룹으로 관리하여 하나만 선택되도록 합니다.

Assets/Scripts/UVC/UI/ToolBar/ToolbarSeparator.cs

@@ -1,4 +1,4 @@
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 툴바 구분선을 나타냅니다.

Assets/Scripts/UVC/UI/ToolBar/ToolbarStandardButton.cs

@@ -1,16 +1,19 @@
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 일반적인 클릭 버튼입니다.
     /// </summary>
     public class ToolbarStandardButton : ToolbarButtonBase
     {
-        public override void ExecuteClick()
-        {
-            if (IsEnabled && OnClick != null)
-            {
-                OnClick.Invoke();
-            }
-        }
+        // 생성자 또는 초기화 메서드가 있다면 ICommand를 받도록 수정
+        // 예: public ToolbarStandardButton(ICommand command) { this.ClickCommand = command; }
+
+        // ToolbarButtonBase의 ExecuteClick을 그대로 사용하거나,
+        // 필요시 override 할 수 있습니다.
+        // public override void ExecuteClick()
+        // {
+        //     base.ExecuteClick(); // 기본 Command 실행
+        //     // 추가적인 StandardButton만의 로직
+        // }
     }
 }

Assets/Scripts/UVC/UI/ToolBar/ToolbarToggleButton.cs

@@ -1,6 +1,7 @@
 using System;
+using UnityEngine;
 
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 클릭할 때마다 선택/해제 상태가 변경되는 토글 버튼입니다.
@@ -9,6 +10,21 @@ namespace UVC.UI.ToolBar
     {
         public event Action<bool> OnToggleStateChanged; // IsSelected 변경 시 IsSelected 값을 전달하는 이벤트
 
+
+        protected string _offIconSpritePath;
+        public string OffIconSpritePath
+        {
+            get => _offIconSpritePath;
+            set
+            {
+                if (_offIconSpritePath != value)
+                {
+                    _offIconSpritePath = value;
+                    NotifyStateChanged();
+                }
+            }
+        }
+
         private bool _isSelected;
         public bool IsSelected
         {
@@ -25,14 +41,28 @@ namespace UVC.UI.ToolBar
         }
         public Action<bool> OnToggle { get; set; }
 
-        public override void ExecuteClick()
+        public override void ExecuteClick(object parameter = null)
         {
-            if (IsEnabled)
+            if (!IsEnabled) return;
+
+            if (parameter is bool newSelectedStateFromUI)
             {
-                IsSelected = !IsSelected; // IsSelected의 setter가 OnStateChanged를 호출
-                OnClick?.Invoke(); // OnClick은 상태 변경과 별개로 클릭 시 항상 호출되도록 할 수 있음
-                OnToggle?.Invoke(IsSelected); // 기존 OnToggle 로직 유지
+                // UI로부터 직접 상태가 전달된 경우 (View의 onValueChanged 리스너)
+                // IsSelected 프로퍼티 setter가 OnToggle 및 NotifyStateChanged를 호출
+                IsSelected = newSelectedStateFromUI;
             }
+            else
+            {
+                // 일반적인 ExecuteClick (파라미터 없거나 bool이 아님) - 기존 토글 로직
+                IsSelected = !IsSelected;
+            }
+
+            OnToggle?.Invoke(IsSelected); // IsSelected는 이미 위에서 최종 상태로 설정됨
+
+            // ClickCommand 실행. 필요하다면 IsSelected나 다른 값을 파라미터로 전달.
+            // 여기서는 parameter 인자로 받은 값을 우선 사용하고, 없으면 IsSelected를 사용.
+            object commandParameter = parameter ?? IsSelected;
+            ClickCommand?.Execute(commandParameter);
         }
     }
 }

Assets/Scripts/UVC/UI/ToolBar/ToolbarView.cs

@@ -2,53 +2,109 @@
 using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
+using UVC.Extension;
 using UVC.Locale;
+using UVC.UI.Tooltip;
 
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Toolbar
 {
     public class ToolbarView : MonoBehaviour
     {
-        public Toolbar ToolbarModel { get; private set; }
+        protected ToolbarModel ToolbarModel { get; private set; }
 
+        // 이제 이 프리팹들은 ToolbarView GameObject의 Inspector에서 직접 할당해야 합니다.
         public GameObject standardButtonPrefab;
         public GameObject toggleButtonPrefab;
         public GameObject radioButtonPrefab;
         public GameObject expandableButtonPrefab;
         public GameObject separatorPrefab;
         public GameObject subMenuPanelPrefab;
-        public GameObject tooltipPrefab; // 툴팁 UI 프리팹
 
-        private Transform toolbarContainer;
+        public Transform toolbarContainer;
+        public LayoutGroup layoutGroup;
         // UI 요소와 모델을 매핑하여 상태 업데이트 시 사용
-        private Dictionary<ToolbarButtonBase, GameObject> _modelToGameObjectMap = new Dictionary<ToolbarButtonBase, GameObject>();
+        protected Dictionary<ToolbarButtonBase, GameObject> _modelToGameObjectMap = new Dictionary<ToolbarButtonBase, GameObject>();
 
-        private GameObject _activeTooltipInstance;
-        private TextMeshProUGUI _tooltipTextElement;
-        private RectTransform _tooltipRectTransform;
+        // Canvas 참조 (Inspector에서 할당하거나 GetComponentInParent 등으로 찾기)
+        protected Canvas rootCanvas;
 
-        public void Initialize(Toolbar toolbarModel, Transform container)
+        protected virtual void Awake()
         {
-            ToolbarModel = toolbarModel;
-            toolbarContainer = container;
 
-            // UI 레이아웃: toolbarContainer에 VerticalLayoutGroup 또는 HorizontalLayoutGroup 컴포넌트를 추가하고
-            // 자식 크기 제어 (Child Force Expand 등) 옵션을 조정하면 UI 요소들이 자동으로 정렬됩니다.
-            // 예: var layoutGroup = toolbarContainer.GetComponent<HorizontalLayoutGroup>();
-            //     if (layoutGroup == null) layoutGroup = toolbarContainer.gameObject.AddComponent<HorizontalLayoutGroup>();
-            //     layoutGroup.childControlHeight = true; layoutGroup.childControlWidth = false; // 예시 설정
-
-            RenderToolbar();
-
-            if (tooltipPrefab != null)
+            if (toolbarContainer == null)
             {
-                _activeTooltipInstance = Instantiate(tooltipPrefab, transform); // ToolbarView의 자식으로 생성 (Canvas 내 다른 곳이어도 됨)
-                _tooltipTextElement = _activeTooltipInstance.GetComponentInChildren<TextMeshProUGUI>();
-                _tooltipRectTransform = _activeTooltipInstance.GetComponent<RectTransform>();
-                _activeTooltipInstance.SetActive(false); // 처음에는 숨김
+                toolbarContainer = GetComponent<Transform>();
+            }
+            if (toolbarContainer == null)
+            {
+                toolbarContainer = GetComponentInChildren<Transform>();
+            }
+
+            if (layoutGroup == null)
+            {
+                layoutGroup = toolbarContainer.gameObject.GetComponent<VerticalLayoutGroup>();
+            }
+            if (layoutGroup == null)
+            {
+                layoutGroup = toolbarContainer.gameObject.AddComponent<VerticalLayoutGroup>();
+            }
+
+
+            // TooltipVisualManager 초기화
+            // rootCanvas가 Inspector에서 할당되지 않았다면 여기서 찾아야 합니다.
+            if (rootCanvas == null)
+            {
+                rootCanvas = GetComponentInParent<Canvas>();
+                if (rootCanvas == null)
+                {
+                    // 최상위 Canvas를 찾기 위한 더 강력한 방법 (예: FindObjectOfType<Canvas>() 후 필터링)
+                    // 또는 씬에 하나의 메인 Canvas만 있다는 가정 하에 동작
+                    Canvas[] canvases = FindObjectsByType<Canvas>(FindObjectsSortMode.InstanceID);
+                    foreach (Canvas c in canvases)
+                    {
+                        if (c.isRootCanvas)
+                        {
+                            rootCanvas = c;
+                            break;
+                        }
+                    }
+                    if (rootCanvas == null && canvases.Length > 0) rootCanvas = canvases[0]; // 최후의 수단
+                }
+            }
+
+            if (rootCanvas != null)
+            {
+                // defaultParent는 툴팁이 생성될 위치입니다. 
+                // rootCanvas.transform을 사용하면 Canvas 직속 자식으로 생성됩니다.
+                // 또는 툴팁 전용 레이어를 두고 싶다면 해당 Transform을 사용합니다.
+                TooltipManager.Instance.Initialize(rootCanvas.transform, rootCanvas);
+            }
+            else
+            {
+                if (rootCanvas == null) Debug.LogError("ToolbarView: rootCanvas를 찾을 수 없어 TooltipVisualManager를 초기화할 수 없습니다.");
             }
         }
 
-        private void ClearToolbar()
+        public virtual void Initialize(ToolbarModel toolbarModel)
+        {
+            ToolbarModel = toolbarModel;
+
+            if (toolbarContainer == null)
+            {
+                Debug.LogError("toolbarContainer가 할당되지 않았습니다.");
+                return;
+            }
+
+            if (layoutGroup == null)
+            {
+                Debug.LogError("layoutGroup이 할당되지 않았습니다.");
+                return;
+            }
+
+            RenderToolbar();
+        }
+
+        protected virtual void ClearToolbar()
         {
             foreach (var pair in _modelToGameObjectMap)
             {
@@ -75,10 +131,10 @@ namespace UVC.UI.ToolBar
             _modelToGameObjectMap.Clear();
             _toggleGroups.Clear(); // 토글 그룹도 정리
             if (currentSubMenu != null) Destroy(currentSubMenu);
-            HideTooltip(); // 툴바가 클리어될 때 툴팁도 숨김
+            TooltipManager.Instance.HideTooltip(); // 툴바가 클리어될 때 툴팁도 숨김
         }
 
-        private void RenderToolbar()
+        protected void RenderToolbar()
         {
             ClearToolbar(); // 기존 UI 및 이벤트 구독 정리
 
@@ -114,117 +170,40 @@ namespace UVC.UI.ToolBar
                             TooltipHandler tooltipHandler = itemObj.GetComponent<TooltipHandler>();
                             if (tooltipHandler == null) tooltipHandler = itemObj.AddComponent<TooltipHandler>();
 
-                            tooltipHandler.TooltipKey = buttonModel.TooltipKey;
-                            tooltipHandler.OnPointerEnterAction = HandlePointerEnter;
-                            tooltipHandler.OnPointerExitAction = HandlePointerExit;
+                            tooltipHandler.Tooltip = buttonModel.TooltipKey;
+                            tooltipHandler.OnPointerEnterAction = TooltipManager.Instance.HandlePointerEnter;
+                            tooltipHandler.OnPointerExitAction = TooltipManager.Instance.HandlePointerExit;
                         }
                     }
                 }
             }
-        }
 
-        private void HandlePointerEnter(string tooltipKey, Vector3 mousePosition)
-        {
-            if (LocalizationManager.Instance != null && _tooltipTextElement != null)
+            // 모든 항목이 추가된 후 toolbarContainer의 높이를 layoutGroup의 내용에 맞게 조절합니다.
+            if (layoutGroup != null)
             {
-                string tooltipText = LocalizationManager.Instance.GetString(tooltipKey);
-                if (string.IsNullOrEmpty(tooltipText) || tooltipText == $"[{tooltipKey}]") // 번역 실패 또는 키 그대로 반환 시
+                // layoutGroup 컴포넌트가 있는 RectTransform을 가져옵니다.
+                // 일반적으로 toolbarContainer의 RectTransform과 동일합니다.
+                RectTransform layoutRectTransform = layoutGroup.GetComponent<RectTransform>();
+                if (layoutRectTransform != null)
                 {
-                    // 번역이 없거나 실패한 경우 툴팁을 표시하지 않거나, 기본 메시지를 표시할 수 있습니다.
-                    // 여기서는 표시하지 않도록 합니다.
-                    HideTooltip();
-                    return;
+                    // 레이아웃을 즉시 재계산하도록 강제합니다.
+                    // 이렇게 하면 preferredHeight가 현재 자식들을 기준으로 정확하게 계산됩니다.
+                    LayoutRebuilder.ForceRebuildLayoutImmediate(layoutRectTransform);
+
+                    // LayoutGroup에 의해 계산된 선호 높이를 가져옵니다.
+                    float preferredHeight = LayoutUtility.GetPreferredHeight(layoutRectTransform);
+
+                    // toolbarContainer (즉, layoutRectTransform)의 높이를 설정합니다.
+                    // 이 코드는 toolbarContainer의 높이가 sizeDelta.y에 의해 제어된다고 가정합니다.
+                    // 앵커가 수직으로 늘어나도록 설정된 경우, 이 방식이 원하는 대로 작동하지 않거나
+                    // anchoredPosition 및 오프셋을 대신 조정해야 할 수 있습니다.
+                    layoutRectTransform.sizeDelta = new Vector2(layoutRectTransform.sizeDelta.x, preferredHeight);
                 }
-                ShowTooltip(tooltipText, mousePosition);
-            }
-        }
-
-        private void HandlePointerExit()
-        {
-            HideTooltip();
-        }
-
-        private void ShowTooltip(string text, Vector3 mousePosition)
-        {
-            if (_activeTooltipInstance == null || _tooltipTextElement == null) return;
-
-            _tooltipTextElement.text = text;
-            _activeTooltipInstance.SetActive(true);
-
-            // 툴팁 위치 설정 (마우스 커서 기준, 화면 가장자리 넘어가지 않도록 조정 필요)
-            // Canvas Render Mode에 따라 위치 계산 방식이 달라질 수 있습니다.
-            // Screen Space - Overlay 예시:
-            if (_tooltipRectTransform != null)
-            {
-                // TextMeshPro의 preferredWidth/Height를 사용하여 크기 조절
-                _tooltipTextElement.ForceMeshUpdate(); // 텍스트 변경 후 메시 업데이트 강제
-                Vector2 textSize = _tooltipTextElement.GetRenderedValues(false);
-                Vector2 padding = new Vector2(10, 5); // 툴팁 내부 여백
-                _tooltipRectTransform.sizeDelta = textSize + padding * 2;
-
-
-                // 화면 가장자리 처리 (간단한 예시)
-                Vector2 localPoint;
-                RectTransformUtility.ScreenPointToLocalPointInRectangle(
-                    transform.root as RectTransform, // Canvas의 최상위 RectTransform
-                    mousePosition,
-                    transform.root.GetComponent<Canvas>().worldCamera, // Screen Space - Camera 경우 필요
-                    out localPoint
-                );
-
-                // 툴팁을 마우스 오른쪽 아래에 표시 (오프셋 조정 가능)
-                _tooltipRectTransform.localPosition = localPoint + new Vector2(_tooltipRectTransform.sizeDelta.x * 0.5f + 10f, -_tooltipRectTransform.sizeDelta.y * 0.5f - 5f);
-
-
-                // 화면 경계 체크 및 위치 조정 (더 정교한 로직 필요)
-                Vector3[] corners = new Vector3[4];
-                _tooltipRectTransform.GetWorldCorners(corners);
-                float screenWidth = Screen.width;
-                float screenHeight = Screen.height;
-
-                // 오른쪽 경계 넘어감
-                if (corners[2].x > screenWidth)
-                {
-                    Vector3 currentPos = _tooltipRectTransform.position;
-                    currentPos.x -= (corners[2].x - screenWidth);
-                    _tooltipRectTransform.position = currentPos;
-                }
-                // 왼쪽 경계 넘어감
-                if (corners[0].x < 0)
-                {
-                    Vector3 currentPos = _tooltipRectTransform.position;
-                    currentPos.x -= corners[0].x;
-                    _tooltipRectTransform.position = currentPos;
-                }
-                // 아래쪽 경계 넘어감 (툴팁을 위로 표시하도록 변경 가능)
-                if (corners[0].y < 0)
-                {
-                    Vector3 currentPos = _tooltipRectTransform.position;
-                    currentPos.y -= corners[0].y; // 위로 올림
-                    // 또는 마우스 위쪽으로 위치 변경
-                    // _tooltipRectTransform.localPosition = localPoint + new Vector2(_tooltipRectTransform.sizeDelta.x * 0.5f + 10f, _tooltipRectTransform.sizeDelta.y * 0.5f + 5f);
-                    _tooltipRectTransform.position = currentPos;
-                }
-                // 위쪽 경계 넘어감
-                if (corners[1].y > screenHeight)
-                {
-                    Vector3 currentPos = _tooltipRectTransform.position;
-                    currentPos.y -= (corners[1].y - screenHeight);
-                    _tooltipRectTransform.position = currentPos;
-                }
-            }
-        }
-
-        private void HideTooltip()
-        {
-            if (_activeTooltipInstance != null)
-            {
-                _activeTooltipInstance.SetActive(false);
             }
         }
 
         // 버튼 모델과 게임 오브젝트를 받아 초기 시각적 요소 설정 및 UI 상호작용을 연결합니다.
-        private void SetupButtonVisualsAndInteractions(ToolbarButtonBase model, GameObject itemObj)
+        protected void SetupButtonVisualsAndInteractions(ToolbarButtonBase model, GameObject itemObj)
         {
             // 공통 UI 요소 업데이트 (Text, Icon, Enabled)
             UpdateCommonButtonVisuals(model, itemObj);
@@ -242,7 +221,7 @@ namespace UVC.UI.ToolBar
                     {
                         // UI에서 사용자가 직접 토글한 경우 모델 업데이트
                         // 중요: 라디오 버튼은 그룹에 의해 선택이 관리되므로, isSelected가 true일 때만 모델 업데이트 요청
-                        if (isSelected) radioModel.ExecuteClick(); // 모델의 ExecuteClick -> RadioGroup.SetSelected 호출
+                        if (isSelected) radioModel.ExecuteClick(true); // 모델의 ExecuteClick -> RadioGroup.SetSelected 호출
                     });
                     // IsSelected 변경은 OnStateChanged를 통해 UpdateItemVisuals에서 처리되거나,
                     // 좀 더 명시적인 OnToggleStateChanged 이벤트를 사용할 수 있습니다.
@@ -281,14 +260,14 @@ namespace UVC.UI.ToolBar
                 {
                     uiButton.onClick.AddListener(() =>
                     {
-                        standardModel.ExecuteClick();
+                        standardModel.ExecuteClick(standardModel.Text);
                     });
                 }
             }
         }
 
         // 모델의 상태가 변경되었을 때 호출되어 모든 관련 UI를 업데이트합니다.
-        private void UpdateItemVisuals(ToolbarButtonBase model)
+        protected void UpdateItemVisuals(ToolbarButtonBase model)
         {
             if (_modelToGameObjectMap.TryGetValue(model, out GameObject itemObj))
             {
@@ -308,7 +287,7 @@ namespace UVC.UI.ToolBar
         }
 
         // 특정 토글 버튼/라디오 버튼의 IsSelected 상태가 모델에서 변경되었을 때 호출됩니다.
-        private void UpdateToggleVisuals(ToolbarToggleButton model, bool isSelected)
+        protected void UpdateToggleVisuals(ToolbarToggleButton model, bool isSelected)
         {
             if (_modelToGameObjectMap.TryGetValue(model, out GameObject itemObj))
             {
@@ -322,7 +301,7 @@ namespace UVC.UI.ToolBar
 
 
         // 공통 버튼 시각적 요소(텍스트, 아이콘, 활성화 상태)를 업데이트합니다.
-        private void UpdateCommonButtonVisuals(ToolbarButtonBase model, GameObject itemObj)
+        protected void UpdateCommonButtonVisuals(ToolbarButtonBase model, GameObject itemObj)
         {
             // 프리팹 구조에 대한 가정:
             // - 텍스트는 TextMeshProUGUI 컴포넌트를 가진 자식 오브젝트에 표시됩니다.
@@ -344,19 +323,51 @@ namespace UVC.UI.ToolBar
                 }
             }
 
-            Transform iconTransform = itemObj.transform.Find("Icon"); // 프리팹에 "Icon" 자식 오브젝트가 있다고 가정
-            if (iconTransform != null)
+            Image buttonIcon = itemObj.GetComponent<Image>();
+            
+            if (buttonIcon != null)
             {
-                Image buttonIcon = iconTransform.GetComponent<Image>();
+                // Toggle이 있는 경우, 아이콘의 활성화 상태를 토글의 선택 상태에 따라 변경
+                if (model is ToolbarToggleButton toolbarToggleButton)
+                {
+                    buttonIcon.sprite = LoadSpriteFromResources(toolbarToggleButton.IsSelected ? toolbarToggleButton.IconSpritePath : toolbarToggleButton.OffIconSpritePath);
+                }
+                else if (model is ToolbarRadioButton radioButtonModel)
+                {
+                    // 라디오 버튼의 아이콘은 선택 상태에 따라 다르게 설정할 수 있습니다.
+                    buttonIcon.sprite = LoadSpriteFromResources(radioButtonModel.IsSelected ? model.IconSpritePath : radioButtonModel.OffIconSpritePath);
+                }
+                else
+                {
+                    buttonIcon.sprite = LoadSpriteFromResources(model.IconSpritePath);
+                }
+                buttonIcon.gameObject.SetActive(model.IconSpritePath != null);
+            }
+            else
+            {
+                buttonIcon = itemObj.GetComponentInChildren<Image>();
                 if (buttonIcon != null)
                 {
-                    buttonIcon.sprite = model.Icon;
-                    buttonIcon.gameObject.SetActive(model.Icon != null);
+                    // Toggle이 있는 경우, 아이콘의 활성화 상태를 토글의 선택 상태에 따라 변경
+                    if (model is ToolbarToggleButton toolbarToggleButton)
+                    {
+                        buttonIcon.sprite = LoadSpriteFromResources(toolbarToggleButton.IsSelected ? toolbarToggleButton.IconSpritePath : toolbarToggleButton.OffIconSpritePath);
+                    }
+                    else if (model is ToolbarRadioButton radioButtonModel)
+                    {
+                        // 라디오 버튼의 아이콘은 선택 상태에 따라 다르게 설정할 수 있습니다.
+                        buttonIcon.sprite = LoadSpriteFromResources(radioButtonModel.IsSelected ? model.IconSpritePath : radioButtonModel.OffIconSpritePath);
+                    }
+                    else
+                    {
+                        buttonIcon.sprite = LoadSpriteFromResources(model.IconSpritePath);
+                    }
+                    buttonIcon.gameObject.SetActive(model.IconSpritePath != null);
                 }
             }
 
-            // 상호작용 가능 상태 업데이트
-            Selectable selectable = itemObj.GetComponent<Selectable>(); // Button, Toggle 등
+                // 상호작용 가능 상태 업데이트
+                Selectable selectable = itemObj.GetComponent<Selectable>(); // Button, Toggle 등
             if (selectable != null)
             {
                 selectable.interactable = model.IsEnabled;
@@ -364,13 +375,15 @@ namespace UVC.UI.ToolBar
         }
 
 
-        private Dictionary<string, ToggleGroup> _toggleGroups = new Dictionary<string, ToggleGroup>();
-        private ToggleGroup GetOrCreateToggleGroup(string groupName)
+        protected Dictionary<string, ToggleGroup> _toggleGroups = new Dictionary<string, ToggleGroup>();
+        protected ToggleGroup GetOrCreateToggleGroup(string groupName)
         {
             if (!_toggleGroups.TryGetValue(groupName, out ToggleGroup group))
             {
                 GameObject groupObj = new GameObject($"ToggleGroup_{groupName}");
                 groupObj.transform.SetParent(toolbarContainer);
+                RectTransform groupRect = groupObj.AddComponent<RectTransform>();
+                groupRect.sizeDelta = new Vector2(0, 0); // 크기는 필요에 따라 조정
                 group = groupObj.AddComponent<ToggleGroup>();
                 group.allowSwitchOff = false; // 라디오 버튼 그룹은 일반적으로 하나는 선택되어 있도록 함
                 _toggleGroups.Add(groupName, group);
@@ -378,9 +391,9 @@ namespace UVC.UI.ToolBar
             return group;
         }
 
-        private GameObject currentSubMenu = null;
+        protected GameObject currentSubMenu = null;
         // expandableButtonObj는 확장 메뉴의 위치를 잡기 위해 사용될 수 있습니다.
-        private void ToggleSubMenu(ToolbarExpandableButton expandableButton, GameObject expandableButtonObj)
+        protected void ToggleSubMenu(ToolbarExpandableButton expandableButton, GameObject expandableButtonObj)
         {
             if (currentSubMenu != null)
             {
@@ -392,8 +405,9 @@ namespace UVC.UI.ToolBar
             if (subMenuPanelPrefab == null || expandableButton.SubButtons.Count == 0) return;
 
             currentSubMenu = Instantiate(subMenuPanelPrefab, transform); // ToolbarView의 자식으로 생성 후 위치 조정
-                                                                         // 위치 조정 로직: expandableButtonObj의 위치를 기준으로 currentSubMenu의 RectTransform을 조정합니다.
-                                                                         // 예: currentSubMenu.transform.position = expandableButtonObj.transform.position + offset;
+            // 위치 조정 로직: expandableButtonObj의 위치를 기준으로 currentSubMenu의 RectTransform을 조정합니다.
+            Vector3 offset = new Vector3(expandableButtonObj.GetComponent<RectTransform>().rect.width, 0, 0);
+            currentSubMenu.transform.position = expandableButtonObj.transform.position + offset;
 
             RectTransform panelRect = currentSubMenu.GetComponent<RectTransform>();
             // 하위 메뉴 패널에 LayoutGroup이 있다면 자식 버튼들이 자동으로 정렬됩니다.
@@ -415,8 +429,11 @@ namespace UVC.UI.ToolBar
                         subUiButton.interactable = subItem.IsEnabled; // 상호작용 상태 설정
                         subUiButton.onClick.AddListener(() =>
                         {
-                            expandableButton.SelectSubButton(subItem); // 모델 업데이트 및 주 버튼 외형 변경 요청
+                            //expandableButton.SelectSubButton(subItem); // 모델 업데이트 및 주 버튼 외형 변경 요청
                                                                        // 주 버튼 UI는 expandableButton의 OnStateChanged 이벤트에 의해 자동으로 업데이트됩니다.
+                            subItem.ExecuteClick(subItem.Text); // 하위 버튼의 Command 실행
+                            expandableButton.OnSubButtonSelected?.Invoke(subItem); // 주 버튼에 하위 버튼 선택 알림
+
                             Destroy(currentSubMenu);
                             currentSubMenu = null;
                         });
@@ -428,9 +445,9 @@ namespace UVC.UI.ToolBar
                         TooltipHandler tooltipHandler = subButtonObj.GetComponent<TooltipHandler>();
                         if (tooltipHandler == null) tooltipHandler = subButtonObj.AddComponent<TooltipHandler>();
 
-                        tooltipHandler.TooltipKey = subItem.TooltipKey;
-                        tooltipHandler.OnPointerEnterAction = HandlePointerEnter;
-                        tooltipHandler.OnPointerExitAction = HandlePointerExit;
+                        tooltipHandler.Tooltip = subItem.TooltipKey;
+                        tooltipHandler.OnPointerEnterAction = TooltipManager.Instance.HandlePointerEnter;
+                        tooltipHandler.OnPointerExitAction = TooltipManager.Instance.HandlePointerExit;
                     }
 
                     // 하위 버튼 모델의 OnStateChanged도 구독하여 하위 버튼 자체의 상태 변경(예: 텍스트)도 반영할 수 있습니다.
@@ -440,14 +457,33 @@ namespace UVC.UI.ToolBar
             }
         }
 
-        void OnDestroy()
+        /// <summary>
+        /// 지정된 경로에서 Sprite를 로드합니다. Sprite 파일은 Resources 폴더 또는 그 하위 폴더에 있어야 합니다.
+        /// </summary>
+        /// <param name="spritePath">Resources 폴더 기준의 Sprite 경로입니다 (확장자 제외).</param>
+        /// <returns>로드된 Sprite 객체. 실패 시 null을 반환합니다.</returns>
+        protected Sprite LoadSpriteFromResources(string spritePath)
+        {
+            if (string.IsNullOrEmpty(spritePath))
+            {
+                Debug.LogWarning("LoadSpriteFromResources: spritePath가 null이거나 비어있습니다.");
+                return null;
+            }
+            Sprite loadedSprite = Resources.Load<Sprite>(spritePath);
+            if (loadedSprite == null)
+            {
+                Debug.LogError($"LoadSpriteFromResources: Resources 폴더에서 '{spritePath}' 경로의 Sprite를 로드할 수 없습니다.");
+            }
+            return loadedSprite;
+        }
+
+
+
+        protected virtual void OnDestroy()
         {
             // 씬 전환 등으로 ToolbarView가 파괴될 때 모든 이벤트 구독 해제
             ClearToolbar();
-            if (_activeTooltipInstance != null)
-            {
-                Destroy(_activeTooltipInstance); // 툴팁 인스턴스도 파괴
-            }
+            TooltipManager.Instance.Dispose(); // 툴팁 인스턴스도 파괴
         }
     }
 }

Assets/Scripts/UVC/UI/Toolbar/ToolbarController.cs

@@ -0,0 +1,171 @@
+using UnityEngine;
+using UVC.Locale;
+using UVC.UI.Commands;
+
+namespace UVC.UI.Toolbar
+{
+    public class ToolbarController : MonoBehaviour
+    {
+        protected ToolbarModel mainToolbar;
+        protected ToolbarView mainToolbarView;
+
+
+        protected virtual void Awake()
+        {
+            // 1. 이 GameObject에 연결된 ToolbarView 컴포넌트를 찾습니다.
+            mainToolbarView = GetComponent<ToolbarView>();
+
+            // 2. 만약 현재 GameObject에 없다면, 자식 GameObject들 중에서 ToolbarView 컴포넌트를 찾습니다.
+            if (mainToolbarView == null)
+            {
+                mainToolbarView = GetComponentInChildren<ToolbarView>();
+            }
+
+        }
+
+        protected virtual void Start()
+        {
+            mainToolbar = new ToolbarModel();
+
+            // ToolbarView에 프리팹 설정은 ToolbarView 내부에서 처리하거나 Inspector에서 직접 할당합니다.
+            if (mainToolbarView == null)
+            {
+                Debug.LogError("ToolbarView가 할당되지 않았습니다.");
+                return;
+            }
+
+            // --- 툴바 모델 구성 ---
+
+            // 요청하신 기능으로 툴바 구성
+            // 1. 카메라 조절 (RadioButtonGroup)
+            mainToolbar.AddRadioButton("CameraControlGroup", "Top View", true,
+                "Prefabs/UI/Toolbar/images/ic_camera_top_on",
+                "Prefabs/UI/Toolbar/images/ic_camera_top_off",
+                (isSelected) => { if (isSelected) Debug.Log("탑뷰 카메라 선택됨"); },
+                new ActionCommand(() => Debug.Log("탑뷰 카메라 Command 실행")),
+                "Top View 시점으로 변경합니다.");
+            mainToolbar.AddRadioButton("CameraControlGroup", "Quarter View", false,
+                "Prefabs/UI/Toolbar/images/ic_camera_quarter_on",
+                "Prefabs/UI/Toolbar/images/ic_camera_quarter_off",
+                (isSelected) => { if (isSelected) Debug.Log("쿼터뷰 카메라 선택됨"); },
+                new ActionCommand(() => Debug.Log("쿼터뷰 카메라 Command 실행")),
+                "Quarter View 시점으로 변경합니다.");
+            mainToolbar.AddRadioButton("CameraControlGroup", "Front View", false,
+                "Prefabs/UI/Toolbar/images/ic_camera_top_on",
+                "Prefabs/UI/Toolbar/images/ic_camera_top_off",
+                (isSelected) => { if (isSelected) Debug.Log("프런트뷰 카메라 선택됨"); },
+                new ActionCommand(() => Debug.Log("프런트뷰 카메라 Command 실행")),
+                "Front View 시점으로 변경합니다.");
+
+            // 2. 구분선
+            mainToolbar.AddSeparator();
+
+            // 3. 객체 선택
+            mainToolbar.AddStandardButton("선택",
+                "Prefabs/UI/Toolbar/images/ic_select",
+                new ActionCommand(() => Debug.Log("객체 선택 버튼 클릭됨")),
+                "객체를 선택합니다.");
+
+            // 4. 객체 이동
+            mainToolbar.AddStandardButton("이동",
+                "Prefabs/UI/Toolbar/images/ic_move",
+                new ActionCommand(() => Debug.Log("객체 이동 버튼 클릭됨")),
+                "객체를 이동 시킵니다.");
+
+            // 5. 객체 회전
+            mainToolbar.AddStandardButton("회전",
+                "Prefabs/UI/Toolbar/images/ic_rotation",
+                new ActionCommand(() => Debug.Log("객체 회전 버튼 클릭됨")),
+                "객체의 각도를 조절합니다.");
+
+            // 6. 객체 크기조절
+            mainToolbar.AddStandardButton("크기조절",
+                "Prefabs/UI/Toolbar/images/ic_scale",
+                new ActionCommand(() => Debug.Log("객체 크기조절 버튼 클릭됨")),
+                "객체 크기를 조절합니다.");
+
+            // 7. 객체 복제
+            mainToolbar.AddStandardButton("복제",
+                "Prefabs/UI/Toolbar/images/ic_copy",
+                new ActionCommand(() => Debug.Log("객체 복제 버튼 클릭됨")),
+                "객체를 복제 합니다.");
+
+            // 8. 객체 삭제
+            mainToolbar.AddStandardButton("삭제",
+                "Prefabs/UI/Toolbar/images/ic_delete",
+                new ActionCommand(() => Debug.Log("객체 삭제 버튼 클릭됨")),
+                "객체를 삭제 합니다.");
+
+            mainToolbar.AddSeparator();
+
+            // 9. 화면 캡처
+            mainToolbar.AddStandardButton("button_capture_screen",
+                "Prefabs/UI/Toolbar/images/ic_chapture",
+                new ActionCommand(() => Debug.Log("화면 캡처 버튼 클릭됨")),
+                "tooltip_capture_screen");
+
+            // 10. 화면 녹화 시작/중지 (ToggleButton)
+            mainToolbar.AddToggleButton("button_record_screen", false,
+                "Prefabs/UI/Toolbar/images/ic_record_on",
+                "Prefabs/UI/Toolbar/images/ic_record_off",
+                (isSelected) => Debug.Log($"화면 녹화 상태: {(isSelected ? "녹화 중" : "중지")} (OnToggle 콜백)"),
+                new ActionCommand<bool>((isRecording) => Debug.Log($"화면 녹화 Command 실행: {(isRecording ? "녹화 시작" : "녹화 중지")}")),
+                "tooltip_record_screen");
+
+
+            // 기존 확장 버튼 (예시로 남겨두거나 필요에 따라 수정/제거)
+            var expandableBtnModel = mainToolbar.AddExpandableButton("button_brush_size",
+                "Prefabs/UI/Toolbar/images/ic_brush_default",
+                new ActionCommand(() => Debug.Log("브러시 크기 주 버튼 클릭됨 (Command)")),
+                "붓 사이즈 선택 합니다.");
+
+            var smallBrushCmd = new ActionCommand<float>((size) => Debug.Log($"작은 브러시 ({size}) 선택됨"), 5.0f);
+            var smallBrush = new ToolbarStandardButton
+            {
+                Text = "brush_size_small",
+                IconSpritePath = "Prefabs/UI/Toolbar/images/ic_brush_small",
+                TooltipKey = "tooltip_brush_small",
+                ClickCommand = smallBrushCmd
+            };
+            expandableBtnModel.SubButtons.Add(smallBrush);
+
+            var mediumBrush = new ToolbarStandardButton
+            {
+                Text = "brush_size_medium",
+                IconSpritePath = "Prefabs/UI/Toolbar/images/ic_brush_medium",
+                TooltipKey = "tooltip_brush_medium",
+                ClickCommand = new ActionCommand(() => Debug.Log("중간 브러시 선택됨 (Sub-Command 실행)"))
+            };
+            expandableBtnModel.SubButtons.Add(mediumBrush);
+
+            expandableBtnModel.OnSubButtonSelected = (selectedSubButtonModel) =>
+            {
+                string localizedSubButtonText = LocalizationManager.Instance != null ? LocalizationManager.Instance.GetString(selectedSubButtonModel.Text) : selectedSubButtonModel.Text;
+                Debug.Log($"브러시 크기 '{localizedSubButtonText}' 선택됨 (OnSubButtonSelected 콜백). 주 버튼 업데이트 로직 실행 가능.");
+            };
+            // --- 툴바 모델 구성 끝 ---
+
+
+            // ToolbarView 초기화 및 렌더링
+            mainToolbarView.Initialize(mainToolbar);
+
+
+            // 예시: 모델 상태를 코드로 변경하고 UI가 업데이트되는지 테스트
+            // StartCoroutine(TestModelChange(saveBtnModel, muteToggleModel));
+        }
+
+        
+
+        // System.Collections.IEnumerator TestModelChange(ToolbarStandardButton standard, ToolbarToggleButton toggle)
+        // {
+        //     yield return new WaitForSeconds(2f);
+        //     Debug.Log("모델 변경 테스트: 저장 버튼 비활성화 및 텍스트 변경");
+        //     standard.Text = "저장됨";
+        //     standard.IsEnabled = false;
+        //
+        //     yield return new WaitForSeconds(2f);
+        //     Debug.Log("모델 변경 테스트: 음소거 토글 상태 변경");
+        //     toggle.IsSelected = true;
+        // }
+    }
+}

Assets/Scripts/UVC/UI/Toolbar/ToolbarModel.cs

@@ -1,15 +1,18 @@
-namespace UVC.UI.ToolBar
+using UnityEngine;
+using UVC.UI.Commands;
+
+namespace UVC.UI.Toolbar
 {
     /// <summary>
     /// 툴바의 전체적인 컨테이너 및 관리 클래스입니다.
     /// IToolbarItem 객체들을 동적으로 추가하고 관리합니다.
     /// </summary>
-    public class Toolbar
+    public class ToolbarModel
     {
         public System.Collections.Generic.List<IToolbarItem> Items { get; private set; }
         private System.Collections.Generic.Dictionary<string, ToolbarRadioButtonGroup> _radioGroups;
 
-        public Toolbar()
+        public ToolbarModel()
         {
             Items = new System.Collections.Generic.List<IToolbarItem>();
             _radioGroups = new System.Collections.Generic.Dictionary<string, ToolbarRadioButtonGroup>();
@@ -31,23 +34,23 @@
             // UI 갱신 로직 호출
         }
 
-        public ToolbarStandardButton AddStandardButton(string text, UnityEngine.Sprite icon = null, System.Action onClick = null, string tooltipKey = null)
+        public ToolbarStandardButton AddStandardButton(string text, string iconSpritePath = null, ICommand command = null, string tooltipKey = null)
         {
-            var button = new ToolbarStandardButton { Text = text, Icon = icon, OnClick = onClick, TooltipKey = tooltipKey };
+            var button = new ToolbarStandardButton { Text = text, IconSpritePath = iconSpritePath, ClickCommand = command, TooltipKey = tooltipKey };
             AddItem(button);
             return button;
         }
 
-        public ToolbarToggleButton AddToggleButton(string text, bool initialState = false, UnityEngine.Sprite icon = null, System.Action<bool> onToggle = null, string tooltipKey = null)
+        public ToolbarToggleButton AddToggleButton(string text, bool initialState = false, string onIconSpritePath = null, string offIconSpritePath = null, System.Action<bool> onToggle = null, ICommand command = null, string tooltipKey = null)
         {
-            var button = new ToolbarToggleButton { Text = text, IsSelected = initialState, Icon = icon, OnToggle = onToggle, TooltipKey = tooltipKey };
+            var button = new ToolbarToggleButton { Text = text, IsSelected = initialState, IconSpritePath = onIconSpritePath, OffIconSpritePath = offIconSpritePath, OnToggle = onToggle, ClickCommand = command, TooltipKey = tooltipKey };
             AddItem(button);
             return button;
         }
 
-        public ToolbarRadioButton AddRadioButton(string groupName, string text, bool initialState = false, UnityEngine.Sprite icon = null, System.Action<bool> onToggle = null, string tooltipKey = null)
+        public ToolbarRadioButton AddRadioButton(string groupName, string text, bool initialState = false, string iconSpritePath = null, string offIconSpritePath = null, System.Action<bool> onToggle = null, ICommand command = null, string tooltipKey = null)
         {
-            var button = new ToolbarRadioButton(groupName) { Text = text, IsSelected = initialState, Icon = icon, OnToggle = onToggle, TooltipKey = tooltipKey };
+            var button = new ToolbarRadioButton(groupName) { Text = text, IsSelected = initialState, IconSpritePath = iconSpritePath, OffIconSpritePath = offIconSpritePath, OnToggle = onToggle, ClickCommand = command, TooltipKey = tooltipKey };
             // AddItem 내에서 그룹 처리가 되므로, 여기서는 IsSelected 초기값만 주의 (그룹 내 하나만 true여야 함)
             AddItem(button);
             // 그룹의 초기 선택 상태를 설정하는 로직이 추가로 필요할 수 있습니다.
@@ -59,9 +62,9 @@
             return button;
         }
 
-        public ToolbarExpandableButton AddExpandableButton(string text, UnityEngine.Sprite icon = null, System.Action onClick = null, string tooltipKey = null)
+        public ToolbarExpandableButton AddExpandableButton(string text, string iconSpritePath = null, ICommand command = null, string tooltipKey = null)
         {
-            var button = new ToolbarExpandableButton { Text = text, Icon = icon, OnClick = onClick, TooltipKey = tooltipKey };
+            var button = new ToolbarExpandableButton { Text = text, IconSpritePath = iconSpritePath, ClickCommand = command, TooltipKey = tooltipKey };
             AddItem(button);
             return button;
         }

Assets/Scripts/UVC/UI/Tooltip.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7423e86407a2a72418bf784190acd2b2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/UVC/UI/Tooltip/TooltipHandler.cs

@@ -2,19 +2,19 @@
 using UnityEngine.EventSystems;
 using UnityEngine.UI;
 
-namespace UVC.UI.ToolBar
+namespace UVC.UI.Tooltip
 {
     public class TooltipHandler : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
     {
         public System.Action<string, Vector3> OnPointerEnterAction; // 툴팁 내용(키), 마우스 위치
         public System.Action OnPointerExitAction;
-        public string TooltipKey { get; set; }
+        public string Tooltip { get; set; }
 
         public void OnPointerEnter(PointerEventData eventData)
         {
-            if (!string.IsNullOrEmpty(TooltipKey) && gameObject.GetComponent<Selectable>()?.interactable == true) // 버튼이 활성화 상태일 때만
+            if (!string.IsNullOrEmpty(Tooltip) && gameObject.GetComponent<Selectable>()?.interactable == true) // 버튼이 활성화 상태일 때만
             {
-                OnPointerEnterAction?.Invoke(TooltipKey, Input.mousePosition);
+                OnPointerEnterAction?.Invoke(Tooltip, Input.mousePosition);
             }
         }
 

Assets/Scripts/UVC/UI/Tooltip/TooltipManager.cs

@@ -0,0 +1,276 @@
+using TMPro;
+using UnityEngine;
+using UVC.Locale; // LocalizationManager를 사용한다면 필요합니다.
+
+namespace UVC.UI.Tooltip
+{
+    public class TooltipManager
+    {
+
+        #region Singleton Implementation
+        private static TooltipManager _instance;
+        public static TooltipManager Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new TooltipManager();
+                }
+                return _instance;
+            }
+        }
+        // 외부에서 직접 생성하지 못하도록 protected 생성자로 변경
+        protected TooltipManager() { }
+        #endregion
+
+        protected Transform _defaultParentTransform; // 툴팁 인스턴스가 생성될 기본 부모 Transform
+        protected Canvas _rootCanvas; // 화면 좌표 계산 및 UI 스케일링에 사용될 Canvas
+
+        protected GameObject _activeTooltipInstance;
+        protected TextMeshProUGUI _tooltipTextElement;
+        protected RectTransform _tooltipRectTransform;
+
+        protected bool _isInitialized = false;
+
+        protected string tooltipPrefabPath = "Prefabs/UI/Tooltip/Tooltip";
+        protected virtual string TooltipPrefabPath => tooltipPrefabPath;
+
+        /// <summary>
+        /// TooltipVisualManager를 초기화합니다. 이 메서드는 한 번만 호출되어야 합니다.
+        /// 일반적으로 애플리케이션 시작 시점이나 UI 시스템이 로드될 때 호출됩니다.
+        /// </summary>
+        /// <param name="defaultParent">생성된 툴팁 인스턴스의 기본 부모 Transform입니다. 보통 Canvas의 Transform입니다.</param>
+        /// <param name="rootCanvas">툴팁의 위치와 크기를 계산하는 데 사용될 최상위 Canvas입니다.</param>
+        /// <param name="tooltipPrefabPath">Resources 폴더 내의 툴팁 UI 프리팹 경로입니다.</param>
+        public void Initialize(Transform defaultParent, Canvas rootCanvas, string tooltipPrefabPath = null)
+        {
+            if (_isInitialized)
+            {
+                Debug.LogWarning("TooltipVisualManager는 이미 초기화되었습니다.");
+                return;
+            }
+
+            if (defaultParent == null)
+            {
+                Debug.LogError("TooltipVisualManager 초기화 실패: defaultParent가 null입니다.");
+                return;
+            }
+            if (rootCanvas == null)
+            {
+                Debug.LogError("TooltipVisualManager 초기화 실패: rootCanvas가 null입니다.");
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(tooltipPrefabPath))
+            {
+                this.tooltipPrefabPath = tooltipPrefabPath; // 사용자 지정 경로가 제공되면 업데이트
+            }
+
+            GameObject loadedTooltipPrefab = Resources.Load<GameObject>(this.tooltipPrefabPath);
+
+            if (loadedTooltipPrefab == null)
+            {
+                Debug.LogError($"TooltipManager 초기화 실패: Resources 폴더에서 '{this.tooltipPrefabPath}' 경로의 프리팹을 로드할 수 없습니다.");
+                return;
+            }
+
+            _defaultParentTransform = defaultParent;
+            _rootCanvas = rootCanvas;
+
+            // 툴팁 인스턴스 생성 및 초기화
+            _activeTooltipInstance = GameObject.Instantiate(loadedTooltipPrefab, _defaultParentTransform);
+            _tooltipTextElement = _activeTooltipInstance.GetComponentInChildren<TextMeshProUGUI>();
+            _tooltipRectTransform = _activeTooltipInstance.GetComponent<RectTransform>();
+
+            if (_tooltipTextElement == null || _tooltipRectTransform == null)
+            {
+                Debug.LogError("TooltipVisualManager 초기화 실패: tooltipPrefab의 구성요소가 올바르지 않습니다. TextMeshProUGUI와 RectTransform이 필요합니다.");
+                if (_activeTooltipInstance != null) GameObject.Destroy(_activeTooltipInstance);
+                _activeTooltipInstance = null; // 초기화 실패 상태로 설정
+                return;
+            }
+
+            _activeTooltipInstance.SetActive(false); // 처음에는 숨김
+            _isInitialized = true;
+            // Debug.Log("TooltipVisualManager 초기화 완료.");
+        }
+
+        public void HandlePointerEnter(string tooltip, Vector3 mousePosition)
+        {
+            if (!_isInitialized || _activeTooltipInstance == null)
+            {
+                // Debug.LogWarning("TooltipVisualManager가 초기화되지 않았거나 툴팁 인스턴스가 없습니다.");
+                return;
+            }
+
+            string tooltipText = tooltip; // 기본값은 키 자체
+            if (LocalizationManager.Instance != null && !string.IsNullOrEmpty(tooltip))
+            {
+                string localizedText = LocalizationManager.Instance.GetString(tooltip);
+                if (!string.IsNullOrEmpty(localizedText) && localizedText != tooltip) // 번역 성공 시
+                {
+                    tooltipText = localizedText;
+                }
+                else if (string.IsNullOrEmpty(localizedText)) // 번역 결과가 비어있으면 숨김
+                {
+                    HideTooltip();
+                    return;
+                }
+            }
+
+            if (string.IsNullOrEmpty(tooltipText))
+            {
+                HideTooltip();
+                return;
+            }
+            ShowTooltip(tooltipText, mousePosition);
+        }
+
+        public void HandlePointerExit()
+        {
+            if (!_isInitialized) return;
+            HideTooltip();
+        }
+
+        private void ShowTooltip(string text, Vector3 mousePosition)
+        {
+            if (_activeTooltipInstance == null || _tooltipTextElement == null || _tooltipRectTransform == null) return;
+
+            _tooltipTextElement.text = text;
+            _activeTooltipInstance.SetActive(true);
+
+            _tooltipTextElement.ForceMeshUpdate();
+            Vector2 textSize = _tooltipTextElement.GetRenderedValues(false);
+            Vector2 padding = new Vector2(10, 2); // 툴팁 내부 여백 (값 증가)
+            _tooltipRectTransform.sizeDelta = textSize + padding * 2;
+
+            AdjustPosition(mousePosition);
+        }
+
+        private void AdjustPosition(Vector3 mousePosition)
+        {
+            if (_rootCanvas == null || _tooltipRectTransform == null) return;
+
+            Vector2 localPoint;
+            Camera eventCamera = (_rootCanvas.renderMode == RenderMode.ScreenSpaceOverlay) ? null : _rootCanvas.worldCamera;
+            RectTransformUtility.ScreenPointToLocalPointInRectangle(
+                _rootCanvas.transform as RectTransform,
+                mousePosition,
+                eventCamera,
+                out localPoint
+            );
+
+            // 툴팁을 마우스 오른쪽 아래에 표시 (오프셋 조정)
+            // Pivot이 (0,1) (좌상단)이라고 가정하고 위치 조정
+            Vector2 pivotOffset = new Vector2(
+                _tooltipRectTransform.sizeDelta.x * _tooltipRectTransform.pivot.x + 10f,
+                _tooltipRectTransform.sizeDelta.y * (1 - _tooltipRectTransform.pivot.y)
+            );
+
+            Debug.Log($"Tooltip Positioning: Local Point = {localPoint}, Pivot Offset = {pivotOffset}");
+
+            // 기본 위치: 마우스 포인터의 오른쪽 아래
+            //Vector2 tooltipPosition = localPoint + new Vector2(0f, -0f - _tooltipRectTransform.sizeDelta.y);
+
+
+            // Pivot을 고려하여 최종 localPosition 설정
+            // _tooltipRectTransform.localPosition = tooltipPosition; // Pivot (0.5, 0.5) 기준이라면 이렇게 간단할 수 있음
+            // 현재는 Pivot에 따라 위치를 보정하는 코드가 복잡해질 수 있으므로,
+            // 툴팁 프리팹의 Pivot을 (0,1) (좌상단) 또는 (0.5, 0.5) (중앙) 등으로 통일하는 것을 권장합니다.
+            // 여기서는 간단히 localPoint를 기준으로 오프셋만 적용합니다. 실제 Pivot에 맞게 조정 필요.
+            _tooltipRectTransform.localPosition = localPoint + pivotOffset;// localPoint + new Vector2(15, -_tooltipRectTransform.sizeDelta.y - 15);
+
+
+            // 화면 경계 처리
+            AdjustPositionWithinScreenBounds();
+        }
+
+
+        public void HideTooltip()
+        {
+            if (_activeTooltipInstance != null)
+            {
+                _activeTooltipInstance.SetActive(false);
+            }
+        }
+
+        private void AdjustPositionWithinScreenBounds()
+        {
+            if (_tooltipRectTransform == null || _activeTooltipInstance == null || !_activeTooltipInstance.activeSelf || _rootCanvas == null) return;
+
+            Vector3[] tooltipCorners = new Vector3[4];
+            _tooltipRectTransform.GetWorldCorners(tooltipCorners); // 툴팁의 월드 좌표 코너
+
+            RectTransform canvasRectTransform = _rootCanvas.transform as RectTransform;
+            Vector3[] canvasCorners = new Vector3[4];
+            canvasRectTransform.GetWorldCorners(canvasCorners); // 캔버스의 월드 좌표 코너 (Screen Space Overlay에서는 화면 전체)
+
+            // Screen Space Overlay에서는 Screen.width/height를 사용하는 것이 더 직관적일 수 있음
+            float minX = 0;
+            float maxX = Screen.width;
+            float minY = 0;
+            float maxY = Screen.height;
+
+            if (_rootCanvas.renderMode != RenderMode.ScreenSpaceOverlay)
+            {
+                // Screen Space Camera 또는 World Space의 경우 캔버스 경계를 사용
+                minX = canvasCorners[0].x; // Bottom-left X
+                maxX = canvasCorners[2].x; // Top-right X
+                minY = canvasCorners[0].y; // Bottom-left Y
+                maxY = canvasCorners[1].y; // Top-left Y (또는 corners[2].y)
+            }
+
+            Vector3 currentPosition = _tooltipRectTransform.position;
+            Vector2 size = _tooltipRectTransform.sizeDelta * _rootCanvas.scaleFactor; // 실제 픽셀 크기
+            Vector2 pivot = _tooltipRectTransform.pivot;
+
+            // 오른쪽 경계 넘어감
+            if (tooltipCorners[2].x > maxX)
+            {
+                currentPosition.x -= (tooltipCorners[2].x - maxX);
+            }
+            // 왼쪽 경계 넘어감
+            if (tooltipCorners[0].x < minX)
+            {
+                currentPosition.x += (minX - tooltipCorners[0].x);
+            }
+            // 아래쪽 경계 넘어감 -> 위로 표시 (마우스 포인터 위쪽으로)
+            if (tooltipCorners[0].y < minY)
+            {
+                // 마우스 포인터의 월드 Y + 약간의 오프셋 + 툴팁 높이 (pivot 고려)
+                Vector3 mouseWorldPos = Vector3.zero;
+                if (_rootCanvas.renderMode == RenderMode.ScreenSpaceOverlay) mouseWorldPos = Input.mousePosition;
+                else RectTransformUtility.ScreenPointToWorldPointInRectangle(canvasRectTransform, Input.mousePosition, _rootCanvas.worldCamera, out mouseWorldPos);
+
+                currentPosition.y = mouseWorldPos.y + (size.y * (1 - pivot.y)) + 15f; // 15f는 오프셋
+            }
+            // 위쪽 경계 넘어감
+            if (tooltipCorners[1].y > maxY) // Top-left corner Y
+            {
+                currentPosition.y -= (tooltipCorners[1].y - maxY);
+            }
+            _tooltipRectTransform.position = currentPosition;
+        }
+
+        /// <summary>
+        /// TooltipVisualManager가 사용하던 리소스를 해제합니다.
+        /// 애플리케이션 종료 시 또는 UI 시스템 해제 시 호출하는 것이 좋습니다.
+        /// </summary>
+        public void Dispose()
+        {
+            if (_activeTooltipInstance != null)
+            {
+                GameObject.Destroy(_activeTooltipInstance);
+                _activeTooltipInstance = null;
+            }
+            _tooltipTextElement = null;
+            _tooltipRectTransform = null;
+            _defaultParentTransform = null;
+            _rootCanvas = null;
+            _isInitialized = false;
+            _instance = null; // 싱글톤 인스턴스 참조 해제
+            // Debug.Log("TooltipVisualManager Disposed.");
+        }
+    }
+}

Assets/Scripts/UVC/UI/Tooltip/TooltipManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fce7ae5b3ec11d541854b89ca1edaf6f